Files
archy/core/target/debug/deps/libmemchr-ae9d1e764ef9df69.rmeta
T

2290 lines
591 KiB
Plaintext
Raw Normal View History

2026-01-24 22:59:20 +00:00
rust
49 #rustc 1.93.0 (254b59607 2026-01-19)Á³VOÐêùÿ²?ÑL¼§Ì±-a7a40eb546f9e2b0Áõ…·fÊ ¦%g--c48c539199cbc88bÁá\ƒ¦è3$|]åŒ[IÚ tæ-14b12edc9f8cd90bÁë&Gf·Ã ¬ëñq:¤»b-bb76018b1173caf6Áà 9m Ù„«ÐÒþá•cB;-030c5b0bba47cc8fÁrustc_std_workspace_coreÁÛ¹þÓ7>H%¸ÚÉ­-4b81d37a5530864dÁüÃùs<Uß7VyóHr#QÏ-c66cc7807550ce25Á miniz_oxideÁõFÖˆÚ™ª‹"ÞXzLVª-62cbc7af83058505Áadler2Á—wÉD‘嵯|6¨%Œ
+-2f171dd2394b4b62Á hashbrownÁ,ïcV¼¨ø¢:Ê\'È߈-9571ba9e0f6c7a90Árustc_std_workspace_allocÁ%¥Èxµù·¼5Ä3Bœ-aac566ad65903fa4Á
std_detectÁMmáýZ^9õ Îà§e˜÷e-2edb296e590136d8Árustc_demangleÁ@¼§VÉNb˜æ¨fHÌ+V3-53b132e4a2fa6e26Ácfg_ifÁfÝv.Å"ÒÜuPp¹ˆ¶-f76b385d7d4d7f3eÁ addr2lineÁÕú-WiúQVÓ¬
µT§5-fe25100bd73e48e4ÁgimliÁ¹xLáÇí÷‘o±Ñ8£Å-265ba9e6e4f70b3fÁobjectÁÔ³ÝzÓÿ¶ò°öM›¼òü`-9ae0d1f8ea52a318ÁmemchrÁRÎ÷׎™te~QÓ¿ØC\Ò-0bff3c8e8f4e489eÁ  –©HtGNÏ·ˆ!á-d69228d077d46f36ÁtestsÁ,Á@à$©@Å,á…à$Ö…{Å,ÿlà$ôlÅ,ªoà$ŸoªÅà$²Å,þÍà$óÍÅ,Í.à$Â.¦Å,è—à$Ý—Å,ä4à$Ù4¼ Ê\€ ¼ ´€ Ù Ê Ù ´Ì «ImpÁœ

á
Ώ
ύ
¼ByteÁ$Ì
à$´
ÈÅ,«³ à$ ³ ¤simd128Á<§
Ê
¼
´Á
¤avx2Á$ 
Ê
Ù
´º
¤ˆ
ÊÙ¤searcher_kind_sse2Á”¯l
Ê\òk
ÙD€l
´òk
¤searcher_kind_avx2Á”¨q
Ê\ëp
ÙDùp
´ëp
¤searcher_kind_simd128Á¬­v
Ê\íu
¼Dûu
´íu
¤prefilter_kind_sse2Áœ‚ï
Ê\Åî
ÙDÓî
´Åî
¤prefilter_kind_avx2Áœ‘ó
Ê\Ôò
ÙDâò
´Ôò
¤prefilter_kind_simd128Á´¬÷
Ê\ìö
¼Dúö
´ìö
Å,²µà$§µŸx86sse2Á<Ð;Ê\³;ÙDÁ;´³;Ÿx86avx2Á<¹EÊ\œEÙDªE´œEŸ wasm_simd128Ád­Ê\ó~¼D´ó~³á 
  
macrosÁlogÁãtraceÁarchÁàì USIZE_BYTESÁ USIZE_ALIGNÁ!
LOOP_BYTESÁ! !findÁ$ !rfindÁ& !Ã!find_rawÁ) ! rfind_rawÁ+ ! count_rawÁ!£ .'aÁ.'hÁ!
has_needleÁ!confirmÁ3¤3­3½3¥ 7 3Ã9 3 size_hintÁ<¤<­< next_backÁ? A AÀC AÏE AæG AùI A£ K¤K­AAÇP¤P­P½P¥ T PW¤W­W¦Z \ \À^ \Ï` \æb \ùd \£ f¤f­\\Çk¤k­k½k¥ o kr¤r­r¦u 
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Á¤Õ¤ÕÀÕÂ8¤do_packed_searchÁÙMIN_LENÁÙMAX_LENÁ find_iterÁÜ­Ü'nÁÜÍ
rfind_iterÁà­àß9àÍÀÏæ­æß9æ æ‘-ë­ëß9ë½ë¥ ëñ­ñß9ñ ñ‘-ö­öß9ö½ö¥ ûß9û ýç,ûÀûÆ9¤­û‘-ûûneedleÁß9 ˆç,ÏŠç,ñ9Œ¤Œ­‘-”< 
build_forwardÁß9ç,build_forward_with_rankerÁß9Ëç,
build_reverseÁß9ç, 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ÁŸ·é?·“@·§@·ñ·é ·É@·ì@·€AŸ aarch64neonÁÀÀÀÀÀŵ>ÅÂ>ÅÄŤÅß>Åó>ʼn?Å™?ÅñÅé Ŷ?ÀјAÀÓé?Ó“@Ó§@ÓñÓé ÓÉ@Óì@Ó€AOneÁÜs1ÁÜ 
àÈ  ãÍOneIterÁå¤å­å†4åitÁ
ê¤ê­êÈî¤î­îÍTwoÁòÓCòs2Áòòv2ÁøÈûÍTwoIterÁý¤ý­ý†4ý«D¤­È¤­ÍThreeÁŠÓCŠÿDŠs3ÁŠŠ‘EŠv3ÁÈÍ ThreeIterÁ¤­†4«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´´‘EÕ ººÈÕ
½Õ ¿¿ÍÕ FÂÂÓCÂÿD½F‘EÂ×FÕ ÊÊÈÕ
ÍÕÏÏÍÕIterÁÒ­Òoriginal_startÁÒŒÒÏÒhaystackÁÕØ­ØÈÕÛ­ÛÍèGÞÞ ÞÞ‘EÞž#ääÈçééͦÈCì
ìì¦ ¦
ðȦ¦óͦ„Dõ¤õ­õ†4õ«D¦ú¤ú­úȦþ¤þ­þͦìD
즦Ȧ¦Í¦ºE¤­†4«D¦¤­È¦¤­Í¦ F˜
˜ì¦¦œÈ¦¦ŸÍ¦€G¡¤¡­¡†4¡«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Á½ æ8½ skippedÁ¤¤ Á Ȥ!¤"Ä Í¤PreÁÆ ¤Æ prestateÁÆ à]¤#Ê ¤Ê ÍFindIterÁÍ ­Í ß9Í íRÍ ”bÍ Ò]Í ÆMÔ ­Ô ß9Ô ÍØ ­Ø ß9Ø È FindRevIterÁÜ ­Ü ß9Ü íRÜ Ò]Ü ÆM â ­â ß9â È
æ ­æ ß9æ ÍèGê ß9ê ”<ê †4 î ß9î È ñ ß9ñ Í®Iô ß9ô ”<ô †4
ø ß9ø Èû ß9û Í
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ÞÏ8KT<Dë‡Þ®{þ®{à`®{Þåå„Dè†4é«D¼¸‘­æÁE¤­à`Š|ÞKŠ|òJŠ|áòòìDóÓCôÿDõöE"ˆÎİwjÞò|þò|à`ò|ÞýýºE†4«DÅž7N£@פ­à`ä}ÞKä}òJä}ኊ FÓCŒÿD½FŽ‘E×F;ˆâbÎZÞÌ~þÌ~à`Ì~Þ€Gš†4«DŠ,Qª(”¸‘¤­à`ÔÞKÔòJÔᤤèG¥ {¦þG{§H{TüNãåÞ¼€þ¼€à`¼€á®®·H¯è{°ö{¿Içz r@Þ¦þ¦à`¦¬ —ðOêrŸJ| ¤ËÞ··èG¸¢¹ƒIøóa_Y•À<à`ł޾¾¿®IÀì  Š T-÷yà`ƒáÅÅÆ¦Çì '9-(r©ÞÓƒþÓƒà`ÓƒÄÓƒ£Óƒ¬âÓƒžÓƒÓƒà`ÕÕèGÖÒJªØäJªäâvClú¹^áÛÛÜèGÝì² ü½r€H8Þþà`áääå®Iæì² Gg,Þö…þö…à`ö…áííõKîƒL²ï’L²ð¦L²¬>6€þ/“ãÞφþφà`φá÷øäLùñL²úÿLû¦L²Å2!Ç¢û4éÞ¼‡þ¼‡à`¼‡à`¸MƒÆM²ñL²ãæÆÂ
¤áˆøMŠŒNô¬3,ÒïBÞéˆþéˆà`éˆáÚNíN˜þNÍÒÖTà&mÞƉþƉà`Ɖ៟ ³O¡ì² ÙãàÝïÞ³Šþ³Šà`³ŠÞ¨¨ÈCªÓCÕ«ÕÌ]±ò6tZßþŒ‹à`Œ‹Þ´´ìDÓCÕ·ÿDÕ¸Õ¹‘EÕ ¬ã°Ñ“7Å‹þè‹à`è‹Þ FÄÓCÕÅÿDÕÆ½FÕÇÕÈ‘EÕÉ×FÕµШDܵÅ‹þÚŒà`ÚŒÞÒÒ³RÔÇRÕÕŒÕÖÏÕ×íRÕÓ
çD/^­à`ä¨âääÞÞÞèGà áâ‘Eãž#Ø6›nå´IIÅ‹þäŽà`äŽáììíÈCîì¦ B‡X!ã;¥ÞÖþÖà`ÖÞõõ„Dø†4¦ù«D¦ »"A‰Ì4¤­à`¯ÞK¯òJ¯ÖN¯áƒìDì¦ ìb°vK›…³Þ§‘þ§‘à`§‘ÞºEކ4¦«D¦ mìøñ¢'¤­à`€’ÞK€’òJ€’ÖN€’ᘘ Fšì¦ ìK.eø•Þø’þø’à`ø’Þ¡¡€G¤†4¦¥«D¦·­Bt9»|¤­à`Ñ“ÞKÑ“òJÑ“ÖNѓᮮ¯èG°ì Š ¸žñBôuÞÉ”þÉ”à`ɔ޾¾¿»XÁì« ¤’©ß
¤à`¢•ÞÈÊËšYÌì«ÍηYÏì«d–JEJŽl¤à`ë•좕½ ½ Ü–ÞÖÖûYدÈÙ«DÈšëñ#Ë2­à`÷–ÞK÷–òJ÷–ÖN÷–ÞààËZâ¯ÈãµÈä«DÈKŒ¢ªï‘™­à`é—ÞKé—òJé—ÖNé—Þëë¤[í¯ÈîµÈïÈð«DÈM¾žßáêd­à`ç˜ÞKç˜òJç˜ÖNç˜Þ÷÷…\ø¤ù¯ ¤úô¤ “ÝLÉ‹‡à`ñ™áýýº\þÎ\¤ÿÛ\¤ë\¤ ú\¤ ¤Ùûè¶q"ÞÈšþÈšþ·]ˆ Ò]¤à]¤ù1Ì(šðìØá›Þ›à`›Þ  ”^¯ ¤ô¤6SØ Ý=„
à`£œÞ˜ è^š ú^ ”<¤œ õK Ò]¤ô±n‰|çªà`îœá¢ £ ¤ Ð¥ ¦ ß_;÷*øå|Ô–ÞÕþÕà`ÕÄÕá­ ­ ”`® ¤¯ ¯ ¤° µ`¤± È`¤
¿Î§tHÞ½žþ½žà`½žáô`· ³¤¸  ¤|®_SÙùn)Þ¶Ÿþ¶Ÿá½ ½ °a¾ æ8¤¿ Îa¤}?^£¼ìê~ÞŒ þŒ à`Œ à`Æ Æ bÈ ”b¤É à]¤†­¦PÅ„l¤à`Í Í ÁbÐ íRÑ ”bÒ Ò]Ó ÆMgê¼"°3­ß9Þ³¡ÞK³¡ÞÜ Ü »cß íRà Ò]á ÆMqØ…I1\­ß9à`­¢ÞK­¢Þê ê èGì ”<í †4ª\ÑûëÌ´æß9à`›£Þô ô ®Iö ”<÷ †4¤Òþc&Å
\ß9à`ì£Þþ þ Äeÿ >“RÃt<ÑŠ5à`½¤Ä½¤á


‡fˆ
ìŸ d }F#ñ8Þ‡¥þ‡¥à`‡¥¬‡¥ Å‚łƂ
uint8x16_tÁÇ‚ì ãc²8‘Þ9 á


Ðf
ìÀ ›bsY6[·õÞ°¦þ°¦à`°¦¬°¦ßÜ÷òЍ¤±®ÈÅÞÛçäñíü÷Œ¢Ÿï옱®ƒ ý‡ § ¢ ² ­ ¹ ¶ À ½ ‰


àÜêåøòýŠœ©¤²®º·Á¾ÉÅßÛèäòíý÷š£Ÿ¬¨º´ÊÂØÒäÞðìúõœ˜¦¡²®Â¾ÐÈÚÖåàñëû÷ýŒ ‡ “  ž — ¨ ¢ ³ ­ º ¶ Á ½ Ø Í â Ü î ê ø ô €
þ Š


âÜúòŠ«¤´®ËÅáÛêäôíÿ÷œ¥Ÿ¯¨½´ÍÂçÞò숞˜´®ýŠ ‡ ª ¢ µ ­ ¼ ¶ à ½ Œ


ãÜîåûòýŠ ¬¤µ®¼·Ã¾ÌÅÙÕâÛëäõí÷¦Ÿ±¨¿´ÏÂÛÒéÞóìþõŸ˜ª¡µ®Å¾ÓÈÝÖèàôë±÷Ž ‡ •    — « ¢ È­ Ä ½ Ê Æ Ô Í æ Ü ñ ê û ô
þ


3åPýkÁõメãÖôàƒëëÍ öÜ <åWýrÊõꊡëÖúàë
Îż¢ „
þ ÐÅÒÅÓÅûÒýÒÏõï¡ïÖþàë­¾À Ä ·
Ó
ÅÅ‚áæ
Þþåà`4ËÞK ìòJ J<Ä £¬âž¨âÖNì*½¬
 Œå  ô !1  ÕÍM ÕÍRÔå  þ üÊ 6 ¯µ1ÕÍÕÍ   ö . 1/\üÍ +  .ž ø. 1/\üÞ*"ε,~ˆ


z
2ô¸x%

Û·
1ôÛy%d«… ¬…  ¶…”º… È…ÿ'; T»…ÔÍX ÔÍ\ÿü«…! , Ë… Î…züÁ„,Ú„ Є43ε 5YôÔÍÔÍü#¥"
)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ý(¡Å‹3 64¡Å‹füà(&Ý,ñ(ε-¡Å‹˜¡Å‹d±– ±–Dµ–¡Å‹6 85¡Å‹iü˜–&è,©–ε¢/Œ¡Å‹¡Å‹d¡ç ¡çD¥ç¡Å‹6 85¡Å‹iüˆç&ò,™çε¢/Œ¡Å‹¡Å‹ú250Á250Á 32Á16Á|êP\êP¡ë¥ øP3 6¡ë¥4füÕP%Ç,âPε-¡ë¥¬¡ë¥¤Ñ<
¾¿%ƒ1Å‚9@\ã[
ÅÆ%Óƒ18?ŒÙ

ÛÜ%1φ9@¤Õ 
äå%ö…1φ9@̹É
Ÿ &³Š29@

ìí%Ö1¨¨ÈCªÓCÕ«ÕÌ]±ò6tZßë¥ryts
ƒ%§‘1´´ìDÓCÕ·ÿDÕ¸Õ¹‘EÕ ¬ã°Ñ“7륊„ÄÅ
˜&ø’2 FÄÓCÕÅÿDÕÆ½FÕÇÕÈ‘EÕÉ×FÕµШDܵ륣ªŒ©
®¯%É”1ÞÞèGà áâ‘Eãž#Ø6›nå´II륊¼
¾¿'¾¾¿»XÁì« ¤’©ß
bÈÊËšYÌì«ÍηYÏì«d–JEJŽlµ¼
ÈË'™ê3 
>E
ÈÎ'™ê3BoxÁ샚íƒlÕ°Ù[¢'õ¶ë•E•EEGlobalÁ Ï€ûkW¬ s¦­ü("


&‡¥29@ô h


%°¦18?È«¼Ÿ³ú=á,²>ì4×> ËÞ.<ß> Ïß/dè> Ú‡/<ö> Ó 0dÿ> Ý
°/\? × Ê.<ž? Í ò.D§? Ñ
û/l±? Ü/DÀ? Õ¬0lÊ? ßË/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`.)
ÁÈ«¼Ÿ³µáµì´ ËÞ.³ Ïß/² Ú‡/± Ó 0° Ý
°/¯ × Ê.® Í ò.­ Ñ
û/¬ Ü›/« Õ¬0ª ßË/© ÙûY¨ÖËZ§à¤[¦ëÕØÛ„í=Ò”¥>ÇüÂ>ľÁ³¨« Š|qtfi[^PSEH:=/2$'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ÜåòýŠØ
Õâ ½üÝ
7Œ
,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`.Á$ä˜

 ˜
®{ 
¶ëø°ú°û°Ðü°ý°þ°ìHˈXêE>! é!
$íRDð$<closure_kind>Á%<closure_signature>Á%<upvars>Á%%$% õÅø°ú°û°Ðü°ý°þ°ìHˈXêE>õÅ ®{üâ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¶ëåå„Dè†4é«D¼¸‘­æÁE/0!ŠW!
.$WíRDœWŽWü«X*T®X¡
 ¡
®{! ¹X!
1$ºXchunkÁ,ÀXü Y,<£Y¢
 ¢
®{! «Y!
2$¬Y
haystack_byteÁl²Yüõ^)¤4­554Š|679;ßKàKåKäK97;ú^þ^L¥_$ª_33üË_#$Î_£
 £
Š|Ä3 Ó_3
7¤­$Ø_4ða7˜Ä8°Ä8ÍÄ8878ðÅÇÆ¼°b,³bŠ|33
9¤­$¹b4àb9˜Ä:°Ä:ÍÄ::9:óÅÇÆü°d-L³d¤
 ¤
Š|Ä3 ½d3
;¤­$¾dü…e4¤=­>>=Š|?óJ?Š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†4«DÅž7N£@×LMA¢A
K$œ¢íRD¢¢ ”¢ü±£*T´£¬
 ¬
ò|A ¿£A
N$À£’à,Æ£üȤ,<ˤ­
 ­
ò|A Ó¤A
O$Ô¤ðàlÚ¤ü¾ª)¤Q­RQRä}STVßKàKäKVTêǪLîª$óªPPü”«#$—«®
 ®
ä}ÄP œ«P
T¤­$¡«4¹­T˜ÄU°ÄUÍÄUUTUðÅïìüù­-Lü­¯
 ¯
ä}æP †®P
V¤­$‡®üή4¤X­YXYä}ZóJZÓ®×®ü—¯(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¶ë€Gš†4«DŠ,Qª(”¸‘gh\í\
f$œííRD¢í ”íüµî*T¸î·
 ·
Ì~\ Ãî\
i$Äî’à,Êîü†ð,<‰ð¸
 ¸
Ì~\ ‘ð\
j$’ððàl˜ðüºö+¤l­mmlÔnoqßKàKäKqo¿öÃöLìö$ñökkü’÷#$•÷¹
 ¹
ÔÄk š÷k
o¤­$Ÿ÷4·ùo˜Äp°ÄpÍÄppopðÅ…„ü÷ù-Lúùº
 º
Ôæk „úk
q¤­$…úüÌú6¤s­tstÔuóJuÑúÕúü—û(Lšû»
 »
ÔÄr ¤ûr
u¤­$©û4Çýu˜Äv°ÄvÍÄvvuvðÅ…„üèÿ"lëÿ
w ùÿ¾áôÁ„,ʄ۷»O]”ÍüÖÑ
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.Á
¼
 ¼
¶ëø°ú°û°Ðü°ý°þ°ìHˈXêE>¼€ §

”<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.Áó-Á
 Á
¶ëø°ú°û°Ðü°ý°þ°ìHˈXêE>¦ ÿ-
”<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…‚—ðOêrŸJ|.)…‚üÊ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`.Áÿ0Ëü‡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»ö ù 8 7á<„Ìôü
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ŒæÈÚ
 Ú
¶ëø°ú°û°Ðü°ý°þ°ìHˈXêE>Ý„­ Ô­
¯”<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/
ÁÛÜäåí÷Ÿ Ðª ²³¢ в² Ѳ·bð Æ ²¸˜Yü´ BMO<>\è /\&º»¼½¾üö'#ü£&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á
â
ã
ä
 á
ø°ú°û°Ðü°ý°þ°ìHˈXêE>Æ Æ bÈ ”b¤É à]¤†­¦PÅ„lâ
ã
¶ë ä
¶ëĹ ¯5¹
¼$°5preÁ¾5íRDÜ5”<4õ5ü¶;¡t¹;²å
æ
ç
è
 å
ø°ú°û°Ðü°ý°þ°ìHˈXêE>Æ Æ bÈ ”b¤É à]¤†­¦PÅ„læ
ç
¶ë è
¶ëĹ Ñ;¹
½$Ò;”žä;íRD<”<4<ñL4²<üëH tîH²é
ê
ë
ì
 é
ø°ú°û°Ðü°ý°þ°ìHˈXêE>Æ Æ bÈ ”b¤É à]¤†­¦PÅ„lê
ë
¶ë ì
¶ëĹ †I¹
¾$‡I”ž™IíRD·I”<4ÐI¦L,ç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Äm¦L,ÛmTÑ„¼‡ÅÆüã‡q<懲÷
 ÷
¶ë¼‡Ä ÿ‡Ä
Å”<4÷‡period_lower_boundÁ”ŽˆLd±ˆüïŽq<ò޲ø
 ø
¶ë¼‡Ä Ä
Æ”<4ƒ†ª”š’Ld½\à˜©ˆÈÉüò˜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¶&E 46#%´õ'ÜÜ©âÅ‹ ú' Å‹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üŸ G¬§ LdÉ =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Á
ï‡Æ
ø°ú°û°Ðü°ý°þ°ìHˈXêE>Ö¬¬
­”<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Å^ ¦­  ­ ÖõÅõŬ Ý^¬
½$Þ^Œ,ì^φ_üÝaDü×_F‘Üœ
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ü 9¬®7œÅ(\Œ üÝ?< 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Á
ï‡Ç  Ç ¶ëø°ú°û°Ðü°ý°þ°ìHˈXêE>É” £
˜”<4ü´=üÿDA Create a new "packed pair" finder using the pair of bytes given.ÁÈËüÐGƒ üœ!Ó ÂËüÊE‹þl”ï‡È  È ¶ë¦•ë Í
”<4Å üÍ=t× É  É ¶ë¦É” î
š”<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#é
õÅõÅüÅ
¤n1Áœ
Œ
Ͼ
ü­ n õÅõÅüÅ
¥û‰Ó Œ Ïõ üäzõÅõÅüÅ
¦û‰Šn2ÁŒÏ¸ü¬{õÅõÅüÅ
§û‰Ó­‹ßŒÏüö\‹õÅõÅüÅ
¨û‰œ­‹¨n3Á´ŒÏÖüÒõÅõÅüÅ
©û‰ù­‹öŒŒ,ϳü¾`õÅõÅ
ªû‰âŒÏ<×@Û@¾¿ÈÞ 
Á«¬L
ü°$
¤®®¢•¯°íî°µ


­­¶ëÄŠ
,
Ö  Ö ¢• Ö ¶ë­ 
­
°¤$”
®
¤²²¢•³µ·Ë
ü H
®
 ¤ç,¢•±ç,´´±ªâƒ’ ²
ñƒ’¶ë
³¤ƒ’bytesÁ,Ë
46üú A
»È
 Ë
Ý
8
Ô
7á
ÌÆ
«‡ì¾¾¿»XÁì« ¤’©ß
±±
µ¤â‘,‡
üý &
D
×  × ¢• × ¶ë±
±
¤$•
üÓ3
»¡
 ¤

8
­
7á
ÌŸ

¢•ד±±
·¤
„Ø
¤¹¹ë•º»Ý
ü…&
Œ
 ¤¶ë땸¸
º¤â‘,
ü–
Ȋ
 ç
ù
8
ð
7á
Ìâ
D
Ø  Ø ë• Ø ¶ë¸ ¦
¸
»¤
<à@ä@½Ä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Èšëñ#Ë2Øæ8
×”<4ê8 íRDö8 ü£:C ü¿9L I Returns an iterator over all occurrences of the needle in a haystack, inÁdŒ: reverse.Ádª: ß  ß ¶ë˜£˜£ºš££ Ú@K äÍ€-EÆÖÖûYدÈÙ«DÈšëñ#Ë2ß  Í:
Ù”<4·: íRDÃ: üò<c ü”;J G Returns an iterator over all occurrences of the needles in a haystack.Áß; Ëüã;I †Ýü­<: ØÝdù< Û Û¶ëààËZâ¯ÈãµÈä«DÈKŒ¢ªï‘™Û†=
Ú¯<= µ< = íRD±= #%üí>b üˆ>M J Returns an iterator over all occurrences of the needles in a haystack, inÁdÖ> õËlô> à  à ¶ë˜£˜£ºš££ Ú@K äÍ€-EÆààËZâ¯ÈãµÈä«DÈ
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²¢ bÐÆ ˜¬¤‰œ¬œƒ´Ÿôž»XDÛ¾Ÿ°atü½ ¡…\DŒ÷¢”^\– £ü†(Ðä·ÄüÚ˼¾˜‡lÖxgiVXEGd¨³´µ·¸ÊËÌÙ¢ Æ ½ ÷ ý‡ — ­ ¶ ƒ´)
¤§·H$A
®¤¨ôLL
¤©ÿ4W
²¤ª 
¤«ü\
hjXZHJ8:ü‡&
-lÙ
ñ™­¯°ü¬
º
ë Õа ë ¶ëñ™¬Ë®® ¡
¬·° ¾
Ȱ´Á
­а>Lâ
ê¯4†
”<4™
.0üÛ;~
4Þ;
¤ì  ì ¶ëÅ‚ø°ú°û°Ðü°ý°þ°ìHˈXêE>½žñ™¬ ö;
¬
¯”<4î;
ôL…<
à]D«<
üüE
$ŠF
í î ï ð  í ñ™ î Œ  ï ¶ë ð ¶ëĬ ˜F
¬
°$™F
”bD§F
íRDÎF
”<4çF
üàI"
ñ™²á`²ü‰J@
ŒJ
ñ ò ó  ñ ñ™ ò Á`Á`œÃ`è Á]Ä`bufÁÁ]Ê­\É:•ó ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶ѼѼÒ¼ štÀ.± J
±
²$J
þ —J
œ…W
tŠW
¤ô õ ö ÷  ô ñ™ õ Œ  ö ¶ë ÷ ¶ëÄü„Z™
œŽZ
¤ø ù ú û  ø ñ™ ù Œ  ú ¶ë û ¶ëÄ ²Z
´ _searcherÁL§Z
 _prestateÁLÁZ
 _haystackÁLåZ
·ü<ûZ
üž]š
´¨]
¤ü ý þ ÿ  ü ñ™ ý Œ  þ ¶ë ÿ ¶ëÄ Î]
µ†4DÄ]
üLÝ]
íRD^
·ü<^
üša˜
¬¤a
¤   ƒ   ñ™  Œ   ¶ë ƒ ¶ëÄ Éa
†4D¿a
üLØa
íRDüa
”<4b
üŽf¦
ü˜f$
¤      ñ™  Œ   ¶ë  ¶ëÄ Ìf
·†4DÂf
”bDÛf
íRDþf
”<4“g
ü†{•
ȏz
 ëz
ƒ{
8Ê\ìz
øz
7½Lúz
üæz
{
¤ˆ  Š   ˆ ñ™  Œ  Š ¶ë  ¶ëÄ ²{
¸†4D¨{
üLÁ{
íRDå{
”<4ú{
„ˆ…
£œº»üî†/
ü†
Œ  Œ ¶ë£œ¹ ˆ‡
¹
º”<4€‡
üºŽj
,ÈŽ
 Ž    £œ Ž ¶ë  ¶ëĹ ׎
¹
»$ØŽ
íRDæŽ
”<4ÿŽ
üÿ¡
սŽü¦¢
<©¢
Õ¼¼
½¤ï¢
Õ¿ÌÑ£
<Ô£
¤   Õ¾ Ü£
¾
¿$Ý£
t‹¶
½žÁÄÅÆü‰·
DŒ·
¤ а¦  ¶ëžˆÀË è·
À·° •·
Ȱ´˜·
Áаê¯4¹·
 $Ì·
”<4à·
35Üžº
Œ¤º
¤ü¯Í9
»ÿÌ
 ‚Í
šÍ
8Ê\ƒÍ
Í
7½L‘Í
üýÌ
$²Í
¤ É”  ¶ë½žÀ ÕÍ
À
ÄÒ]4·Í
”<4ÍÍ
üÆÕ0
$ÉÕ
¤    ½ž  ¶ëÄÀ ÎÕ
À
Å$ÏÕ
íRDÕÕ
ü€Ù7
\ƒÙ
¤    ½ž  ¶ëÄÀ Ù
À
Æ$Ù
íRD–Ù
Ý
ƘÄǰÄÇÍÄÇÇÆÇ ½žüÍÝ#
½žÉá`Éü÷Ý@
úÝ
 ˜    ½ž ˜ Á`Á`œÃ`è Á]Ä`¾ŠÁ]Ê­\É:• ä‹È þÝ
È
É$ÿÝ
þ …Þ
¤¸é
|½é
¤š   š ½ž  ¶ëÄüêëa
¼ôë
¤œ   œ ½ž  ¶ëÄ ˜ì
ËstratÁ,‘ì
íRD¨ì
ü›û]
»ýú
 €û
˜û
8Ê\û
û
7½Lû
üûú
œ¥û
¤ž Ÿ  ž ½ž Ÿ ¶ëÄ Åû
ÌþŸ,¾û
íRDÕû
œ‘†
Œ 
settings.Álë©   ½¤ ç,ê ê èGì ”<í †4ª\ÑûëÌ´æç,ù©ªâ¹„ ý©ñ¹„¶ë\‰ª
¹„$ ª”<4®ªKM8:üï¬Åü£«LI Build a forward finder using the given needle and a custom heuristic forÁüô«=: determining the frequency of a given byte in the dataset.Áü¶¬41 See [`HeuristicFrequencyRank`] for more details.ÁÌö¬˜·  · ½¤а ˜ƒ’ê ê èGì ”<í †4ª\ÑûëÌ´æ˜Ëç,šš™­·° ¥­­’ È­Ȱ´¨­¾’\Ô­
аƒ’$ñ­ê¯4ÿ­”<4’®VXLNPRṵ̈oüó¯B? Build a reverse finder using the given needle from the currentÁlº°ò‚lÓ°œ¸  ¸ ½¤ œ¹„ô ô ®Iö ”<÷ †4¤Òþc&Å
\œç,á°¦… å°¸…\ñ°
¹„$ˆ±”<4–±68,.ü´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  ñÕüÔœþùÕà`ùÕ„ô ñÕ:¬.¼$ñÕ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 ±O8Ê\šO ¦O7½L¨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Áò$ êÀÁ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Á}Ç+ ÀÁ vld1_dup_f64Áe±/ ÀÁ
vld1q_dup_f64Ámá1 ‘‚ÀÁ
vld1_lane_f64Ámÿ4 “‚ÀÁvld1q_lane_f64Áu¥8 •‚ÀÁvbsl_f64ÁEæ< —‚ÀÁvbsl_p64ÁEœ@ ˜‚ÀÁ vbslq_f64ÁM‰C ™‚ÀÁ vbslq_p64ÁMÊF š‚ÀÁvadd_f64ÁE¬I ›‚ÀÁ vaddq_f64ÁMªK œ‚ÀÁvadd_s64ÁE¨M ÀÁvadd_u64ÁEŸO ž‚ÀÁ vaddd_s64ÁM™Q Ÿ‚ÀÁ vaddd_u64ÁM÷R  ÀÁvext_p64ÁEU ¡‚ÀÁvext_f64ÁEäW £‚ÀÁ
vdup_n_p64ÁUZ ¥‚ÀÁ
vdup_n_f64ÁU¯\ ¦‚ÀÁ vdupq_n_p64Á]»^ §‚ÀÁ vdupq_n_f64Á]Ü` ¨‚ÀÁ
vmov_n_p64ÁUêb ©‚ÀÁ
vmov_n_f64ÁUíd ª‚ÀÁ vmovq_n_p64Á]ñf «‚ÀÁ vmovq_n_f64Á]öh ¬‚ÀÁ
vget_high_f64Ámüj ­ÀÁ
vget_high_p64Ám£m ®‚ÀÁ vget_low_f64ÁeÐo ¯‚ÀÁ vget_low_p64Áeöq °‚ÀÁ
vget_lane_f64Ám”u ±‚ÀÁvgetq_lane_f64ÁuÐx ³‚ÀÁ 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Á]í0ˆ…ÀÁŠÂ‰…ÀÁ int8x16x4_tÁ]í3“…ÀÁÔ…ÀÁ uint8x8x2_tÁ]ü6Ÿ…ÀÁü …ÀÁ uint8x8x3_tÁ]î9©…ÀÁµÃª…ÀÁ uint8x8x4_tÁ]î<´…ÀÁîõ…ÀÁ uint8x16x2_tÁeþ?À…ÀÁ§ÄÁ…ÀÁ uint8x16x3_tÁeôBÊ…ÀÁáÄË…ÀÁ uint8x16x4_tÁeùEÕ…ÀÁ›ÅÖ…ÀÁ poly8x8x2_tÁ] Iá…ÀÁÕÅâ…ÀÁ poly8x8x3_tÁ]Lë…ÀÁŽÆì…ÀÁ poly8x8x4_tÁ]Oö…ÀÁÇÆ÷…ÀÁ poly8x16x2_tÁe¢R‚†ÀÁ€Çƒ†ÀÁ poly8x16x3_tÁe˜UŒ†ÀÁºÇÀÁ poly8x16x4_tÁeX—†ÀÁôǘ†ÀÁ int16x4x2_tÁ]Ä[£†ÀÁ®È¤†ÀÁ int16x4x3_tÁ]¶^­†ÀÁçÈ®†ÀÁ int16x4x4_tÁ]¶a¸†ÀÁ É¹†ÀÁ int16x8x2_tÁ]ÅdĆÀÁÙÉņÀÁ int16x8x3_tÁ]·gΆÀÁ’ÊφÀÁ int16x8x4_tÁ]·jÙ†ÀÁËÊÚ†ÀÁ uint16x4x2_tÁeÇmå†ÀÁ„Ëæ†ÀÁ uint16x4x3_tÁe½pï†ÀÁ¾Ëð†ÀÁ uint16x4x4_tÁeÂsú†ÀÁøËû†ÀÁ uint16x8x2_tÁeêv†‡ÀÁ²Ì‡‡ÀÁ uint16x8x3_tÁeàyÀÁìÌ‘‡ÀÁ 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æÈĉÀÁàÙʼnÀÁ
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ÁEÉ/ üÕÀÁ__crc32wÁEë6 ÿÕÀÁ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_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©…0 úÞÀÁvld2_s8Á=“‹0 ýÞÀÁvld2q_s8ÁEí0 €ßÀÁvld2_s16ÁEΖ0 ƒßÀÁ vld2q_s16ÁM±œ0 †ßÀÁvld2_s32ÁE–¢0 ‰ßÀÁ vld2q_s32ÁMù§0 ŒßÀÁ
vld2_lane_f16ÁmÀ¿0 ßÀÁvld2q_lane_f16ÁuíÇ0 “ßÀÁ
vld2_lane_f32ÁmØÏ0 —ßÀÁvld2q_lane_f32Áu…×0 ›ßÀÁ vld2_lane_s8Áe¿Þ0 ŸßÀÁ
vld2_lane_s16Ám×å0 £ßÀÁvld2q_lane_s16Áuúì0 §ßÀÁ
vld2_lane_s32ÁmŸô0 «ßÀÁvld2q_lane_s32ÁuÂû0 ¯ßÀÁ vld2_lane_u8Áe‡¹1 ³ßÀÁ
vld2_lane_u16ÁmÞÀ1 µßÀÁvld2q_lane_u16Áu»È1 ·ßÀÁ
vld2_lane_u32Ám™Ð1 ¹ßÀÁvld2q_lane_u32Áuö×1 »ßÀÁ vld2_lane_p8ÁeÓß1 ½ßÀÁ
vld2_lane_p16Ámªç1 ¿ßÀÁvld2q_lane_p16Áu‡ï1 ÁßÀÁvld2_p64ÁE­ö1 ÃßÀÁvld2_s64ÁEÕÿ1 ÄßÀÁvld2_u64ÁEù‡2 ÇßÀÁvld2_u8Á=ÑŽ2 ÈßÀÁvld2q_u8ÁE×2 ÉßÀÁvld2_u16ÁE•®2 ÊßÀÁ vld2q_u16ÁM޽2 ËßÀÁvld2_u32ÁE£Ì2 ÌßÀÁ vld2q_u32ÁMÛ2 ÍßÀÁvld2_p8Á=Œê2 ÎßÀÁvld2q_p8ÁE’ù2 ÏßÀÁvld2_p16ÁEЉ3 ÐßÀÁ vld2q_p16ÁMɘ3 ÑßÀÁ vld3_dup_f16Áe¸³3 ÒßÀÁ
vld3q_dup_f16Ám¶º3 ÕßÀÁ vld3_dup_f32ÁeÅÀ3 ØßÀÁ
vld3q_dup_f32ÁmÒÆ3 ÛßÀÁ vld3_dup_s8Á]àÌ3 ÞßÀÁ vld3q_dup_s8ÁeàÒ3 áßÀÁ vld3_dup_s16ÁeæØ3 äßÀÁ
vld3q_dup_s16ÁmïÞ3 çßÀÁ vld3_dup_s32Áeúä3 êßÀÁ
vld3q_dup_s32Ámƒë3 íßÀÁ vld3_dup_s64ÁeŽñ3 ðßÀÁ vld3_dup_p64Áe‡¨4 óßÀÁ vld3_dup_u64ÁeÈ´4 ôßÀÁ vld3_dup_u8Á]Ç»4 õßÀÁ vld3q_dup_u8ÁeõË4 ößÀÁ vld3_dup_u16Áe³Þ4 ÷ßÀÁ
vld3q_dup_u16ÁmÈî4 øßÀÁ vld3_dup_u32Áe…ÿ4 ùßÀÁ
vld3q_dup_u32Ámˆ5 úßÀÁ vld3_dup_p8Á] Ÿ5 ûßÀÁ vld3q_dup_p8Áeί5 üßÀÁ vld3_dup_p16ÁeŒÂ5 ýßÀÁ
vld3q_dup_p16Ám¡Ò5 þßÀÁvld3_f16ÁEîí5 ÿßÀÁ vld3q_f16ÁMÚô5 ‚àÀÁvld3_f32ÁE¿ú5 …àÀÁ vld3q_f32ÁMª€6 ˆàÀÁvld3_s8Á=–†6 ‹àÀÁvld3q_s8ÁEò‹6 ŽàÀÁvld3_s16ÁEÕ‘6 ‘àÀÁ vld3q_s16ÁMº—6 ”àÀÁvld3_s32ÁE¡6 —àÀÁ vld3q_s32ÁM†£6 šàÀÁ
vld3_lane_f16Ámâæ6 àÀÁvld3q_lane_f16Áußï6 ¡àÀÁ
vld3_lane_f32Ámí÷6 ¥àÀÁvld3q_lane_f32Áuøÿ6 ©àÀÁ vld3_lane_s8Áeå7 ­àÀÁ
vld3_lane_s16ÁmÖ—7 ±àÀÁvld3q_lane_s16ÁuÓŸ7 µàÀÁ
vld3_lane_s32ÁmÒ§7 ¹àÀÁvld3q_lane_s32Áuϯ7 ½àÀÁ 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ÛA ƒâÀÁ vmaxq_u16ÁMø‡A „âÀÁvmax_u32ÁE•ŽA …âÀÁ vmaxq_u32ÁM²”A †âÀÁ
vmaxnm_f16ÁUƒšA ‡âÀÁ vmaxnmq_f16Á]—ŸA ˆâÀÁ
vmaxnm_f32ÁUœ¥A ‰âÀÁ vmaxnmq_f32Á]¡«A ŠâÀÁvmin_f16ÁE°A ‹âÀÁ vminq_f16ÁMÔ·A ŽâÀÁvmin_f32ÁE‹ÀA ‘âÀÁ vminq_f32ÁMÀÈA ”âÀÁvmin_s8Á=öÐA —âÀÁvminq_s8ÁE‰×A ˜âÀÁvmin_s16ÁE¡ÝA ™âÀÁ vminq_s16ÁMºãA šâÀÁvmin_s32ÁEÓéA ›âÀÁ vminq_s32ÁMìïA œâÀÁvmin_u8Á=„öA âÀÁvminq_u8ÁE›üA žâÀÁvmin_u16ÁE·‚B ŸâÀÁ vminq_u16ÁMÔˆB  âÀÁvmin_u32ÁEñŽB ¡âÀÁ vminq_u32ÁMŽ•B ¢âÀÁ
vminnm_f16ÁUßšB £âÀÁ vminnmq_f16Á]óŸB ¤âÀÁ
vminnm_f32ÁUø¥B ¥âÀÁ vminnmq_f32Á]ý«B ¦âÀÁvmla_f32ÁEý±B §âÀÁ vmlaq_f32ÁM—¸B ¨âÀÁ
vmla_lane_f32Ámè¾B ©âÀÁvmla_laneq_f32Áu©ÆB «âÀÁvmlaq_lane_f32ÁuëÍB ­âÀÁvmlaq_laneq_f32Á}„ÖB ¯âÀÁ
vmla_lane_s16Ám›ÞB ±âÀÁ
vmla_lane_u16Ám˜æB ³âÀÁvmla_laneq_s16ÁušîB µâÀÁvmla_laneq_u16Áu™öB ·âÀÁvmlaq_lane_s16ÁuœþB ¹âÀÁvmlaq_lane_u16ÁuÀˆC »âÀÁvmlaq_laneq_s16Á}é’C ½âÀÁvmlaq_laneq_u16Á}C ¿âÀÁ
vmla_lane_s32Ám·§C ÁâÀÁ
vmla_lane_u32Ámß®C ÃâÀÁvmla_laneq_s32ÁuŒ¶C ÅâÀÁvmla_laneq_u32Áu¶½C ÇâÀÁvmlaq_lane_s32ÁuäÄC ÉâÀÁvmlaq_lane_u32ÁuäÌC ËâÀÁvmlaq_laneq_s32Á}éÔC ÍâÀÁvmlaq_laneq_u32Á}ëÜC ÏâÀÁ
vmla_n_f32ÁU·äC ÑâÀÁ vmlaq_n_f32Á]ÀêC ÒâÀÁ
vmla_n_s16ÁUÊðC ÓâÀÁ vmlaq_n_s16Á]ÌöC ÔâÀÁ
vmla_n_u16ÁUÐüC ÕâÀÁ vmlaq_n_u16Á]Õ‚D ÖâÀÁ
vmla_n_s32ÁU܈D ×âÀÁ vmlaq_n_s32Á]ÞŽD ØâÀÁ
vmla_n_u32ÁUâ”D ÙâÀÁ vmlaq_n_u32Á]çšD ÚâÀÁvmla_s8Á=ß D ÛâÀÁvmlaq_s8ÁEÚ¦D ÜâÀÁvmla_s16ÁEÛ¬D ÝâÀÁ vmlaq_s16ÁMݲD ÞâÀÁvmla_s32ÁE߸D ßâÀÁ vmlaq_s32ÁMá¾D àâÀÁvmla_u8Á=áÄD áâÀÁvmlaq_u8ÁEàÊD ââÀÁvmla_u16ÁEåÐD ãâÀÁ vmlaq_u16ÁMëÖD äâÀÁvmla_u32ÁEñÜD åâÀÁ vmlaq_u32ÁM÷âD æâÀÁvmlal_lane_s16ÁuÐéD çâÀÁvmlal_laneq_s16Á}ÝñD éâÀÁvmlal_lane_s32ÁuêùD ëâÀÁvmlal_laneq_s32Á}¢E íâÀÁvmlal_lane_u16ÁuÚˆE ïâÀÁvmlal_laneq_u16Á}ëE ñâÀÁvmlal_lane_u32Áuü˜E óâÀÁvmlal_laneq_u32Á}¸ E õâÀÁ vmlal_n_s16Á]»§E ÷âÀÁ vmlal_n_s32Á]Ë­E øâÀÁ vmlal_n_u16Á]Û³E ùâÀÁ vmlal_n_u32Á]î¹E úâÀÁvmlal_s8ÁEæ¿E ûâÀÁ vmlal_s16ÁMæÅE üâÀÁ vmlal_s32ÁMêËE ýâÀÁvmlal_u8ÁEîÑE þâÀÁ vmlal_u16ÁMô×E ÿâÀÁ vmlal_u32ÁMþÝE €ãÀÁvmls_f32ÁEœäE ãÀÁ vmlsq_f32ÁM½êE ‚ãÀÁ
vmls_lane_f32ÁmŒñE ƒãÀÁvmls_laneq_f32ÁuËøE …ãÀÁvmlsq_lane_f32Áu‹€F ‡ãÀÁvmlsq_laneq_f32Á}¢ˆF ‰ãÀÁ
vmls_lane_s16Ám·F ‹ãÀÁ
vmls_lane_u16Ám²˜F ãÀÁvmls_laneq_s16Áu² F ãÀÁvmls_laneq_u16Áu¯¨F ‘ãÀÁvmlsq_lane_s16Áu°°F “ãÀÁvmlsq_lane_u16ÁuÒºF •ãÀÁvmlsq_laneq_s16Á}ùÄF —ãÀÁvmlsq_laneq_u16Á}ÏF ™ãÀÁ
vmls_lane_s32ÁmÃÙF ›ãÀÁ
vmls_lane_u32ÁméàF ãÀÁvmls_laneq_s32Áu”èF ŸãÀÁvmls_laneq_u32Áu¼ïF ¡ãÀÁvmlsq_lane_s32ÁuèöF £ãÀÁvmlsq_lane_u32ÁuæþF ¥ãÀÁvmlsq_laneq_s32Á}é†G §ãÀÁvmlsq_laneq_u32Á}éŽG ©ãÀÁ
vmls_n_f32ÁU³–G «ãÀÁ vmlsq_n_f32Á]ºœG ¬ãÀÁ
vmls_n_s16ÁU¢G ­ãÀÁ vmlsq_n_s16Á]¨G ®ãÀÁ
vmls_n_u16ÁUÄ®G ¯ãÀÁ vmlsq_n_u16Á]Ç´G °ãÀÁ
vmls_n_s32ÁU̺G ±ãÀÁ vmlsq_n_s32Á]ÌÀG ²ãÀÁ
vmls_n_u32ÁUÎÆG ³ãÀÁ vmlsq_n_u32Á]ÑÌG ´ãÀÁvmls_s8Á=ÐÒG µãÀÁvmlsq_s8ÁEÒØG ¶ãÀÁvmls_s16ÁEÚÞG ·ãÀÁ vmlsq_s16ÁMãäG ¸ãÀÁvmls_s32ÁEìêG ¹ãÀÁ vmlsq_s32ÁMõðG ºãÀÁvmls_u8Á=üöG »ãÀÁvmlsq_u8ÁE‚ýG ¼ãÀÁvmls_u16ÁEŽƒH ½ãÀÁ vmlsq_u16ÁM›‰H ¾ãÀÁvmls_u32ÁE¨H ¿ãÀÁ vmlsq_u32ÁMµ•H ÀãÀÁvmlsl_lane_s16ÁuŒœH ÁãÀÁvmlsl_laneq_s16Á}—¤H ÃãÀÁvmlsl_lane_s32Áu¢¬H ÅãÀÁvmlsl_laneq_s32Á}سH ÇãÀÁvmlsl_lane_u16ÁuŽ»H ÉãÀÁvmlsl_laneq_u16Á}ÃH ËãÀÁvmlsl_lane_u32Áu¬ËH ÍãÀÁvmlsl_laneq_u32Á}æÒH ÏãÀÁ vmlsl_n_s16Á]çÙH ÑãÀÁ vmlsl_n_s32Á]õßH ÒãÀÁ vmlsl_n_u16Á]ƒæH ÓãÀÁ vmlsl_n_u32Á]”ìH ÔãÀÁvmlsl_s8ÁE‘òH ÕãÀÁ vmlsl_s16ÁM–øH ÖãÀÁ vmlsl_s32ÁMŸþH ×ãÀÁvmlsl_u8ÁE¨„I ØãÀÁ vmlsl_u16ÁM³ŠI ÙãÀÁ vmlsl_u32ÁMÂI ÚãÀÁ
vmmlaq_s32ÁUÜ–I ÛãÀÁ
vmmlaq_u32ÁUÙŸI ÞãÀÁ
vmov_n_f16ÁUÛ§I áãÀÁ vmovq_n_f16Á]¶¬I âãÀÁ
vmov_n_f32ÁU”²I ããÀÁ
vmov_n_p16ÁUø·I äãÀÁ vmov_n_p8ÁMÙ½I åãÀÁ
vmov_n_s16ÁU¸ÃI æãÀÁ
vmov_n_s32ÁUšÉI çãÀÁ
vmov_n_s64ÁUúÎI èãÀÁ vmov_n_s8ÁMÚÔI éãÀÁ
vmov_n_u16ÁU¸ÚI êãÀÁ
vmov_n_u32ÁU›àI ëãÀÁ
vmov_n_u64ÁUüåI ìãÀÁ vmov_n_u8ÁMÝëI íãÀÁ vmovq_n_f32Á]½ñI îãÀÁ vmovq_n_p16Á]¤÷I ïãÀÁ
vmovq_n_p8ÁUˆýI ðãÀÁ vmovq_n_s16Á]ë‚J ñãÀÁ vmovq_n_s32Á]ЈJ òãÀÁ vmovq_n_s64Á]²ŽJ óãÀÁ
vmovq_n_s8ÁU•”J ôãÀÁ vmovq_n_u16Á]÷™J õãÀÁ vmovq_n_u32Á]ÝŸJ öãÀÁ vmovq_n_u64Á]À¥J ÷ãÀÁ
vmovq_n_u8ÁU¤«J øãÀÁ vmovl_s16ÁMç°J ùãÀÁ vmovl_s32ÁM±¶J úãÀÁvmovl_s8ÁEú»J ûãÀÁ vmovl_u16ÁMÂÁJ üãÀÁ vmovl_u32ÁMŽÇJ ýãÀÁvmovl_u8ÁEÙÌJ þãÀÁ vmovn_s16ÁM§ÒJ ÿãÀÁ vmovn_s32ÁMô×J €äÀÁ vmovn_s64ÁMÂÝJ äÀÁ vmovn_u16ÁMãJ ‚äÀÁ vmovn_u32ÁMßèJ ƒäÀÁ vmovn_u64ÁM¯îJ „äÀÁvmul_f16ÁE…óJ …äÀÁ vmulq_f16ÁMï÷J †äÀÁvmul_f32ÁEÊýJ ‡äÀÁ vmulq_f32ÁM¥ƒK ˆäÀÁ
vmul_lane_f16ÁmĈK ‰äÀÁvmulq_lane_f16Áu—K ‹äÀÁ
vmul_lane_f32ÁmŽ™K äÀÁvmul_laneq_f32Áu˜ K äÀÁvmulq_lane_f32Áu£§K ‘äÀÁvmulq_laneq_f32Á}ø®K “äÀÁ
vmul_lane_s16Ám¼¶K •äÀÁvmulq_lane_s16Áuù½K —äÀÁ
vmul_lane_s32ÁmÚÇK ™äÀÁvmulq_lane_s32ÁuÎÎK ›äÀÁ
vmul_lane_u16Ám‹ÖK äÀÁvmulq_lane_u16ÁuËÝK ŸäÀÁ
vmul_lane_u32Ám¯çK ¡äÀÁvmulq_lane_u32Áu¦îK £äÀÁvmul_laneq_s16ÁuçõK ¥äÀÁvmulq_laneq_s16Á}¦ýK §äÀÁvmul_laneq_s32Áu‰‡L ©äÀÁvmulq_laneq_s32Á}ÿL «äÀÁvmul_laneq_u16Áu¾•L ­äÀÁvmulq_laneq_u16Á}€L ¯äÀÁvmul_laneq_u32Áuæ¦L ±äÀÁvmulq_laneq_u32Á}ß­L ³äÀÁ
vmul_n_f16ÁUˆ´L µäÀÁ vmulq_n_f16Á]…¹L ¶äÀÁ
vmul_n_f32ÁUô¾L ·äÀÁ vmulq_n_f32Á]âÄL ¸äÀÁ
vmul_n_s16ÁUÐÊL ¹äÀÁ vmulq_n_s16Á]¹ÐL ºäÀÁ
vmul_n_s32ÁU£ÖL »äÀÁ vmulq_n_s32Á]ŒÜL ¼äÀÁ
vmul_n_u16ÁUöáL ½äÀÁ vmulq_n_u16Á]áçL ¾äÀÁ
vmul_n_u32ÁUÍíL ¿äÀÁ vmulq_n_u32Á]¸óL ÀäÀÁvmul_p8Á=œùL ÁäÀÁvmulq_p8ÁEÂM ÄäÀÁvmul_s16ÁEí‰M ÇäÀÁ vmulq_s16ÁMÁM ÈäÀÁvmul_u16ÁE••M ÉäÀÁ vmulq_u16ÁMìšM ÊäÀÁvmul_s32ÁEàM ËäÀÁ vmulq_s32ÁM—¦M ÌäÀÁvmul_u32ÁEë«M ÍäÀÁ vmulq_u32ÁM±M ÎäÀÁvmul_s8Á=—·M ÏäÀÁvmulq_s8ÁEå¼M ÐäÀÁvmul_u8Á=¶ÂM ÑäÀÁvmulq_u8ÁE‡ÈM ÒäÀÁvmull_lane_s16Áu¬ÎM ÓäÀÁvmull_laneq_s16Á}…ÖM ÕäÀÁvmull_lane_s32ÁuÞÝM ×äÀÁvmull_laneq_s32Á}îäM ÙäÀÁvmull_lane_u16ÁuþëM ÛäÀÁvmull_laneq_u16Á}ÚóM ÝäÀÁvmull_lane_u32Áu¶ûM ßäÀÁvmull_laneq_u32Á}É‚N áäÀÁ vmull_n_s16Á]¥‰N ãäÀÁ vmull_n_s32Á]N ääÀÁ vmull_n_u16Á]ù”N åäÀÁ vmull_n_u32Á]åšN æäÀÁvmull_p8ÁEË N çäÀÁ vmull_s16ÁM„©N êäÀÁ vmull_s32ÁM¾±N íäÀÁvmull_s8ÁEö¹N ðäÀÁvmull_u8ÁE©ÂN óäÀÁ vmull_u16ÁMäÊN öäÀÁ vmull_u32ÁM¦ÓN ùäÀÁvmvn_p8Á=ÚÛN üäÀÁvmvn_s16ÁEÆáN ýäÀÁvmvn_s32ÁE²çN þäÀÁvmvn_s8Á=íN ÿäÀÁvmvn_u16ÁE…óN €åÀÁvmvn_u32ÁEøøN åÀÁvmvn_u8Á=ñþN ‚åÀÁvmvnq_p8ÁEÝ„O ƒåÀÁ vmvnq_s16ÁMΊO „åÀÁ vmvnq_s32ÁM¼O …åÀÁvmvnq_s8ÁE©–O †åÀÁ vmvnq_u16ÁM–œO ‡åÀÁ vmvnq_u32ÁM‹¢O ˆåÀÁvmvnq_u8ÁE†¨O ‰åÀÁvneg_f16ÁEÿ¬O ŠåÀÁ vnegq_f16ÁMÔ±O ‹åÀÁvneg_f32ÁEš·O ŒåÀÁ vnegq_f32ÁMà¼O åÀÁvneg_s8Á=£ÂO ŽåÀÁvnegq_s8ÁEßÇO åÀÁvneg_s16ÁEŸÍO åÀÁ vnegq_s16ÁMàÒO ‘åÀÁvneg_s32ÁE¡ØO ’åÀÁ vnegq_s32ÁMâÝO “åÀÁvorn_s16ÁE¶ãO ”åÀÁvorn_s32ÁEÈéO •åÀÁvorn_s64ÁEÚïO –åÀÁvorn_s8Á=ëõO —åÀÁ vornq_s16ÁMùûO ˜åÀÁ vornq_s32ÁMP ™åÀÁ vornq_s64ÁM¡ˆP šåÀÁvornq_s8ÁE´ŽP ›åÀÁvorn_u16ÁEÆ”P œåÀÁvorn_u32ÁEæšP åÀÁvorn_u64ÁE†¡P žåÀÁvorn_u8Á=¥§P ŸåÀÁ vornq_u16ÁMÁ­P  åÀÁ vornq_u32ÁMã³P ¡åÀÁ vornq_u64ÁM…ºP ¢åÀÁvornq_u8ÁE¦ÀP £åÀÁvorr_s8Á=ÎÆP ¤åÀÁvorrq_s8ÁE¶ÌP ¥åÀÁvorr_s16ÁE¢ÒP ¦åÀÁ vorrq_s16ÁMØP §åÀÁvorr_s32ÁEüÝP ¨åÀÁ vorrq_s32ÁMéãP ©åÀÁvorr_s64ÁEÖéP ªåÀÁ vorrq_s64ÁMÃïP «åÀÁvorr_u8Á=¯õP ¬åÀÁvorrq_u8ÁEšûP ­åÀÁvorr_u16ÁE‰Q ®åÀÁ vorrq_u16ÁMù†Q ¯åÀÁvorr_u32ÁEéŒQ °åÀÁ vorrq_u32ÁMÙ’Q ±åÀÁvorr_u64ÁEɘQ ²åÀÁ vorrq_u64ÁM¹žQ ³åÀÁ vpadal_s8ÁM´¤Q ´åÀÁ
vpadalq_s8ÁUö«Q µåÀÁ
vpadal_s16ÁU½³Q ¶åÀÁ vpadalq_s16Á]…»Q ·åÀÁ
vpadal_s32ÁUÏÂQ ¸åÀÁ vpadalq_s32Á]—ÊQ ¹åÀÁ vpadal_u8ÁMáÑQ ºåÀÁ
vpadalq_u8ÁU©ÙQ »åÀÁ
vpadal_u16ÁUöàQ ¼åÀÁ vpadalq_u16Á]ÄèQ ½åÀÁ
vpadal_u32ÁU”ðQ ¾åÀÁ vpadalq_u32Á]â÷Q ¿åÀÁ vpadd_f16ÁM©þQ ÀåÀÁ vpadd_f32ÁMï†R ÃåÀÁvpadd_s8ÁE¥R ÆåÀÁ vpadd_s16ÁMÄ—R ÉåÀÁ vpadd_s32ÁMîŸR ÌåÀÁvpadd_u8ÁE¸¨R ÏåÀÁ vpadd_u16ÁMì¶R ÐåÀÁ vpadd_u32ÁMŠÅR ÑåÀÁ vpaddl_s8ÁM˜ÓR ÒåÀÁ
vpaddlq_s8ÁUÓÛR ÕåÀÁ
vpaddl_s16ÁU–äR ØåÀÁ vpaddlq_s16Á]ÚìR ÛåÀÁ
vpaddl_s32ÁU õR ÞåÀÁ vpaddlq_s32Á]äýR áåÀÁ vpaddl_u8ÁMª†S äåÀÁ
vpaddlq_u8ÁUëŽS çåÀÁ
vpaddl_u16ÁU´—S êåÀÁ vpaddlq_u16Á]þŸS íåÀÁ
vpaddl_u32ÁUʨS ðåÀÁ vpaddlq_u32Á]”±S óåÀÁ vpmax_f32ÁMιS öåÀÁvpmax_s8ÁEšÂS ùåÀÁ vpmax_s16ÁMÐÊS üåÀÁ vpmax_s32ÁM‘ÓS ÿåÀÁvpmax_u8ÁEÑÛS ‚æÀÁ vpmax_u16ÁMäS …æÀÁ vpmax_u32ÁMÔìS ˆæÀÁ vpmin_f32ÁM›õS ‹æÀÁvpmin_s8ÁEçýS ŽæÀÁ vpmin_s16ÁM†T ‘æÀÁ vpmin_s32ÁMÞŽT ”æÀÁvpmin_u8ÁEž—T —æÀÁ vpmin_u16ÁMÚŸT šæÀÁ vpmin_u32ÁM¡¨T æÀÁvqabs_s8ÁEë°T  æÀÁ vqabsq_s8ÁM‡¹T £æÀÁ vqabs_s16ÁM­ÁT ¦æÀÁ
vqabsq_s16ÁUÔÉT ©æÀÁ vqabs_s32ÁMýÑT ¬æÀÁ
vqabsq_s32ÁU¤ÚT ¯æÀÁvqadd_s8ÁE¹âT ²æÀÁ vqaddq_s8ÁMèT ³æÀÁ vqadd_s16ÁM†îT ´æÀÁ
vqaddq_s16ÁUðóT µæÀÁ vqadd_s32ÁMÚùT ¶æÀÁ
vqaddq_s32ÁUÄÿT ·æÀÁ vqadd_s64ÁM®…U ¸æÀÁ
vqaddq_s64ÁU˜‹U ¹æÀÁvqadd_u8ÁE€‘U ºæÀÁ vqaddq_u8ÁMç–U »æÀÁ vqadd_u16ÁMÓœU ¼æÀÁ
vqaddq_u16ÁUÀ¢U ½æÀÁ vqadd_u32ÁM­¨U ¾æÀÁ
vqaddq_u32ÁUš®U ¿æÀÁ vqadd_u64ÁM‡´U ÀæÀÁ
vqaddq_u64ÁUô¹U ÁæÀÁvqdmlal_lane_s16Á…ËÀU ÂæÀÁvqdmlal_lane_s32Á…ëÇU ÄæÀÁ
vqdmlal_n_s16ÁmØÎU ÆæÀÁ
vqdmlal_n_s32Ám‚ÕU ÇæÀÁ vqdmlal_s16Á]“ÛU ÈæÀÁ vqdmlal_s32Á]¦áU ÉæÀÁvqdmlsl_lane_s16Á…ƒèU ÊæÀÁvqdmlsl_lane_s32Á…¡ïU ÌæÀÁ
vqdmlsl_n_s16ÁmŒöU ÎæÀÁ
vqdmlsl_n_s32Ám´üU ÏæÀÁ vqdmlsl_s16Á]Ê‚V ÐæÀÁ vqdmlsl_s32Á]âˆV ÑæÀÁvqdmulh_laneq_s16Á·V ÒæÀÁvqdmulhq_laneq_s16Á•á–V ÔæÀÁvqdmulh_laneq_s32ÁžV ÖæÀÁvqdmulhq_laneq_s32Á•·¥V ØæÀÁ
vqdmulh_n_s16Ám«¬V ÚæÀÁvqdmulhq_n_s16ÁuβV ÛæÀÁ
vqdmulh_n_s32Ámó¸V ÜæÀÁvqdmulhq_n_s32Áu–¿V ÝæÀÁ vqdmulh_s16Á]¼ÅV ÞæÀÁ vqdmulhq_s16Áe£ÎV áæÀÁ vqdmulh_s32Á]Œ×V äæÀÁ vqdmulhq_s32ÁeóßV çæÀÁvqdmull_lane_s16Á…ŒéV êæÀÁvqdmull_lane_s32Á…åðV ìæÀÁ
vqdmull_n_s16Ámù÷V îæÀÁ
vqdmull_n_s32ÁmþV ïæÀÁ vqdmull_s16Á]ûƒW ðæÀÁ vqdmull_s32Á]ÒŒW óæÀÁ
vqmovn_s16ÁU•W öæÀÁ
vqmovn_s32ÁUÀW ùæÀÁ
vqmovn_s64ÁUç¥W üæÀÁ
vqmovn_u16ÁU®W ÿæÀÁ
vqmovn_u32ÁU¹¶W ‚çÀÁ
vqmovn_u64ÁUæ¾W …çÀÁ vqmovun_s16Á]ÇW ˆçÀÁ vqmovun_s32Á]ÓÏW ‹çÀÁ vqmovun_s64Á]ØW ŽçÀÁvqneg_s8ÁEµàW ‘çÀÁ vqnegq_s8ÁMÉèW ”çÀÁ vqneg_s16ÁMçðW —çÀÁ
vqnegq_s16ÁU†ùW šçÀÁ vqneg_s32ÁM§X çÀÁ
vqnegq_s32ÁUƉX  çÀÁvqrdmulh_lane_s16ÁÈ’X £çÀÁvqrdmulh_lane_s32ÁÓšX ¥çÀÁvqrdmulh_laneq_s16Á•¹¢X §çÀÁvqrdmulh_laneq_s32Á•ƪX ©çÀÁvqrdmulhq_lane_s16Á•­²X «çÀÁvqrdmulhq_lane_s32Á•Ÿ¼X ­çÀÁvqrdmulhq_laneq_s16Á®ÄX ¯çÀÁvqrdmulhq_laneq_s32Á¢ÎX ±çÀÁvqrdmulh_n_s16ÁuùÕX ³çÀÁvqrdmulhq_n_s16Á}ÜX ´çÀÁvqrdmulh_n_s32Áu©âX µçÀÁvqrdmulhq_n_s32Á}ÀèX ¶çÀÁ vqrdmulh_s16ÁeÚîX ·çÀÁ
vqrdmulhq_s16ÁmÒ÷X ºçÀÁ vqrdmulh_s32ÁeÌ€Y ½çÀÁ
vqrdmulhq_s32ÁmĉY ÀçÀÁ vqrshl_s8ÁMœ’Y ÃçÀÁ
vqrshlq_s8ÁUàšY ÆçÀÁ
vqrshl_s16ÁU¯£Y ÉçÀÁ vqrshlq_s16Á]ÿ«Y ÌçÀÁ
vqrshl_s32ÁUÑ´Y ÏçÀÁ vqrshlq_s32Á]¡½Y ÒçÀÁ
vqrshl_s64ÁUóÅY ÕçÀÁ vqrshlq_s64Á]ÃÎY ØçÀÁ vqrshl_u8ÁM×Y ÛçÀÁ
vqrshlq_u8ÁUîßY ÞçÀÁ
vqrshl_u16ÁUÊèY áçÀÁ vqrshlq_u16Á]§ñY äçÀÁ
vqrshl_u32ÁU†úY ççÀÁ vqrshlq_u32Á]ã‚Z êçÀÁ
vqrshl_u64ÁU‹Z íçÀÁ vqrshlq_u64Á]Ÿ”Z ðçÀÁ
vqrshrn_n_s16Ám߬Z óçÀÁ
vqrshrn_n_s32Ámî²Z ÷çÀÁ
vqrshrn_n_s64Ám¹Z ûçÀÁ
vqrshrn_n_u16ÁmñÓZ ÿçÀÁ
vqrshrn_n_u32ÁmÚZ ƒèÀÁ
vqrshrn_n_u64Ám­àZ ‡èÀÁvqrshrun_n_s16ÁuýøZ ‹èÀÁvqrshrun_n_s32ÁuÿZ èÀÁvqrshrun_n_s64ÁuÁ…[ “èÀÁ
vqshl_n_s8ÁUŽ[ —èÀÁ vqshlq_n_s8Á]Д[ ™èÀÁ vqshl_n_s16Á]•›[ ›èÀÁ vqshlq_n_s16ÁeÛ¡[ èÀÁ vqshl_n_s32Á]£¨[ ŸèÀÁ vqshlq_n_s32Áeé®[ ¡èÀÁ vqshl_n_s64Á]±µ[ £èÀÁ vqshlq_n_s64Áe÷»[ ¥èÀÁ
vqshl_n_u8ÁUÀÂ[ §èÀÁ vqshlq_n_u8Á]„É[ ©èÀÁ vqshl_n_u16Á]ÍÏ[ «èÀÁ vqshlq_n_u16Áe—Ö[ ­èÀÁ vqshl_n_u32Á]ãÜ[ ¯èÀÁ vqshlq_n_u32Áe­ã[ ±èÀÁ vqshl_n_u64Á]ùé[ ³èÀÁ vqshlq_n_u64ÁeÃð[ µèÀÁvqshl_s8ÁEÚö[ ·èÀÁ vqshlq_s8ÁMÿ[ ºèÀÁ vqshl_s16ÁMˇ\ ½èÀÁ
vqshlq_s16ÁUŠ\ ÀèÀÁ vqshl_s32ÁM˘\ ÃèÀÁ
vqshlq_s32ÁUŠ¡\ ÆèÀÁ vqshl_s64ÁMË©\ ÉèÀÁ
vqshlq_s64ÁUв\ ÌèÀÁvqshl_u8ÁE̺\ ÏèÀÁ vqshlq_u8ÁM…Ã\ ÒèÀÁ vqshl_u16ÁMÉË\ ÕèÀÁ
vqshlq_u16ÁUŽÔ\ ØèÀÁ vqshl_u32ÁMÕÜ\ ÛèÀÁ
vqshlq_u32ÁUšå\ ÞèÀÁ vqshl_u64ÁMáí\ áèÀÁ
vqshlq_u64ÁU¦ö\ äèÀÁ vqshlu_n_s8Á]ã«] çèÀÁ vqshluq_n_s8Áe„²] íèÀÁ vqshlu_n_s16Áe°¸] óèÀÁ
vqshluq_n_s16Ámݾ] ùèÀÁ vqshlu_n_s32ÁeŒÅ] ÿèÀÁ
vqshluq_n_s32Ám²Ë] …éÀÁ vqshlu_n_s64ÁeÚÑ] ‹éÀÁ
vqshluq_n_s64Ám„Ø] éÀÁ vqshrn_n_s16Áeƒð] –éÀÁ vqshrn_n_s32Áe„ö] šéÀÁ vqshrn_n_s64Áe‰ü] žéÀÁ vqshrn_n_u16Áe¥–^ ¢éÀÁ vqshrn_n_u32Áe¬œ^ ¦éÀÁ vqshrn_n_u64Áe·¢^ ªéÀÁ
vqshrun_n_s16ÁmϺ^ ®éÀÁ
vqshrun_n_s32ÁmáÀ^ ²éÀÁ
vqshrun_n_s64Ám÷Æ^ ¶éÀÁvqsub_s8ÁEŒÏ^ ºéÀÁ vqsubq_s8ÁMõÔ^ »éÀÁ vqsub_s16ÁMãÚ^ ¼éÀÁ
vqsubq_s16ÁUÒà^ ½éÀÁ vqsub_s32ÁMÁæ^ ¾éÀÁ
vqsubq_s32ÁU°ì^ ¿éÀÁ vqsub_s64ÁMŸò^ ÀéÀÁ
vqsubq_s64ÁUŽø^ ÁéÀÁvqsub_u8ÁEûý^ ÂéÀÁ vqsubq_u8ÁMçƒ_ ÃéÀÁ vqsub_u16ÁM؉_ ÄéÀÁ
vqsubq_u16ÁUÊ_ ÅéÀÁ vqsub_u32ÁM¼•_ ÆéÀÁ
vqsubq_u32ÁU®›_ ÇéÀÁ vqsub_u64ÁM ¡_ ÈéÀÁ
vqsubq_u64ÁU’§_ ÉéÀÁ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Á¥Õ…a üéÀÁvreinterpret_s32_f16Á¥³‘a ýéÀÁvreinterpret_s64_f16Á¥‹a þéÀÁvreinterpret_u8_f16ÁŒ¨a ÿéÀÁvreinterpret_u16_f16Á¥ó³a €êÀÁvreinterpret_u32_f16Á¥Ô¿a êÀÁvreinterpret_u64_f16Á¥¯Ëa ‚êÀÁvreinterpret_p8_f16Á²Öa ƒêÀÁvreinterpret_p16_f16Á¥™âa „êÀÁvreinterpretq_f32_f16Á­ûía …êÀÁvreinterpretq_s8_f16Á¥îùa †êÀÁvreinterpretq_s16_f16Á­±†b ‡êÀÁvreinterpretq_s32_f16Á­«’b ˆêÀÁvreinterpretq_s64_f16Á­™žb ‰êÀÁvreinterpretq_u8_f16Á¥€ªb ŠêÀÁvreinterpretq_u16_f16Á­Æ¶b ‹êÀÁvreinterpretq_u32_f16Á­ÃÂb ŒêÀÁvreinterpretq_u64_f16Á­´Îb êÀÁvreinterpretq_p8_f16Á¥žÚb ŽêÀÁvreinterpretq_p16_f16Á­äæb êÀÁvreinterpret_f16_f32Á¥àòb êÀÁvreinterpretq_f16_f32Á­¿þb ‘êÀÁvreinterpret_f16_s8Á±Šc ’êÀÁvreinterpretq_f16_s8Á¥•–c “êÀÁvreinterpret_f16_s16Á¥±¢c ”êÀÁvreinterpretq_f16_s16Á­®c •êÀÁvreinterpret_f16_s32Á¥‰ºc –êÀÁvreinterpretq_f16_s32Á­âÅc —êÀÁvreinterpret_f16_s64Á¥ÏÑc ˜êÀÁvreinterpretq_f16_s64Á­éÜc ™êÀÁvreinterpret_f16_u8ÁÏèc šêÀÁvreinterpretq_f16_u8Á¥¶ôc ›êÀÁvreinterpret_f16_u16Á¥Õ€d œêÀÁvreinterpretq_f16_u16Á­·Œd êÀÁvreinterpret_f16_u32Á¥³˜d žêÀÁvreinterpretq_f16_u32Á­¤d ŸêÀÁvreinterpret_f16_u64Á¥ÿ¯d  êÀÁvreinterpretq_f16_u64Á­›»d ¡êÀÁvreinterpret_f16_p8Á„Çd ¢êÀÁvreinterpretq_f16_p8Á¥ëÒd £êÀÁvreinterpret_f16_p16Á¥Šßd ¤êÀÁvreinterpretq_f16_p16Á­ìêd ¥êÀÁvreinterpretq_f16_p128Áµêöd ¦êÀÁvreinterpret_p64_f16Á¥‹‚e §êÀÁvreinterpretq_p128_f16Áµ‘e ¨êÀÁvreinterpretq_p64_f16Á­œ˜e ©êÀÁvreinterpret_f16_p64Á¥†¤e ªêÀÁvreinterpretq_f16_p64Á­¢¯e «êÀÁvreinterpretq_f32_p128Áµÿ»e ¬êÀÁvreinterpret_s8_f32ÁõÈe ­êÀÁvreinterpret_s16_f32Á¥µÖe ®êÀÁvreinterpret_s32_f32Á¥ïãe ¯êÀÁvreinterpret_s64_f32Á¥£ñe °êÀÁvreinterpret_u8_f32Á€þe ±êÀÁvreinterpret_u16_f32Á¥Ã‹f ²êÀÁvreinterpret_u32_f32Á¥€™f ³êÀÁvreinterpret_u64_f32Á¥·¦f ´êÀÁvreinterpret_p8_f32Á–³f µêÀÁvreinterpret_p16_f32Á¥ÙÀf ¶êÀÁvreinterpretq_p128_f32Áµ˜Îf ·êÀÁvreinterpretq_s8_f32Á¥øÚf ¸êÀÁvreinterpretq_s16_f32Á­‘éf ¹êÀÁvreinterpretq_s32_f32Á­áöf ºêÀÁvreinterpretq_s64_f32Á­¥„g »êÀÁvreinterpretq_u8_f32Á¥â‘g ¼êÀÁvreinterpretq_u16_f32Á­þŸg ½êÀÁvreinterpretq_u32_f32Á­Ñ­g ¾êÀÁvreinterpretq_u64_f32Á­˜»g ¿êÀÁvreinterpretq_p8_f32Á¥ØÈg ÀêÀÁvreinterpretq_p16_f32Á­ôÖg ÁêÀÁvreinterpret_f32_s8ÁÅäg ÂêÀÁvreinterpret_s16_s8Á„òg ÃêÀÁvreinterpret_s32_s8ÁÃÿg ÄêÀÁvreinterpret_s64_s8ÁüŒh ÅêÀÁvreinterpret_u8_s8Á•Þ™h ÆêÀÁvreinterpret_u16_s8Á¦§h ÇêÀÁvreinterpret_u32_s8Áè´h ÈêÀÁvreinterpret_u64_s8Á¤Âh ÉêÀÁvreinterpret_p8_s8Á•ˆÏh ÊêÀÁvreinterpret_p16_s8ÁÐÜh ËêÀÁvreinterpretq_f32_s8Á¥“êh ÌêÀÁvreinterpretq_s16_s8Á¥…øh ÍêÀÁvreinterpretq_s32_s8Á¥ý…i ÎêÀÁvreinterpretq_s64_s8Á¥é“i ÏêÀÁvreinterpretq_u8_s8ÁΡi ÐêÀÁvreinterpretq_u16_s8Á¥’°i ÑêÀÁvreinterpretq_u32_s8Á¥¾i ÒêÀÁvreinterpretq_u64_s8Á¥üËi ÓêÀÁvreinterpretq_p8_s8ÁäÙi ÔêÀÁ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ÁuDZŠ ÞîÀÁ
vset_lane_u32Ám¸Š àîÀÁ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ÁÜŒ –ïÀÁ
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ÁĘž íòÀÁ 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Á…þ´¦ ØôÀÁ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_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ÙA úžÀÁ vabdh_f16ÁM¤E ûžÀÁvabdl_high_s16ÁuÆH üžÀÁvabdl_high_s32ÁuM ýžÀÁ
vabdl_high_s8ÁmÑQ þžÀÁ
vabdl_high_u8Ám½V ÿžÀÁvabdl_high_u16Áu†[ €ŸÀÁvabdl_high_u32Áu¯_ ŸÀÁvabs_f64ÁEÀc ‚ŸÀÁ vabsq_f64ÁM´f ƒŸÀÁvabs_s64ÁE¤i „ŸÀÁ vabsq_s64ÁMm …ŸÀÁ vabsd_s64ÁMáp †ŸÀÁ
vaddlv_s16ÁUÅz ‹ŸÀÁ 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_f32ÁMŒë ÆŸÀÁ
vamaxq_f32ÁU¯ð ÉŸÀÁ
vamaxq_f64Á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¼ÿ — ÀÁ