api-docs/crates-enclave/src/memchr/memmem/mod.rs.html - incubator-teaclave-website - Git at Google

 <!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta name="generator" content="rustdoc"><meta name="description" content="Source of the Rust file `/root/.cargo/registry/src/github.com-1ecc6299db9ec823/memchr-2.5.0/src/memmem/mod.rs`."><meta name="keywords" content="rust, rustlang, rust-lang"><title>mod.rs - source</title><link rel="preload" as="font" type="font/woff2" crossorigin href="../../../SourceSerif4-Regular.ttf.woff2"><link rel="preload" as="font" type="font/woff2" crossorigin href="../../../FiraSans-Regular.woff2"><link rel="preload" as="font" type="font/woff2" crossorigin href="../../../FiraSans-Medium.woff2"><link rel="preload" as="font" type="font/woff2" crossorigin href="../../../SourceCodePro-Regular.ttf.woff2"><link rel="preload" as="font" type="font/woff2" crossorigin href="../../../SourceSerif4-Bold.ttf.woff2"><link rel="preload" as="font" type="font/woff2" crossorigin href="../../../SourceCodePro-Semibold.ttf.woff2"><link rel="stylesheet" href="../../../normalize.css"><link rel="stylesheet" href="../../../rustdoc.css" id="mainThemeStyle"><link rel="stylesheet" href="../../../ayu.css" disabled><link rel="stylesheet" href="../../../dark.css" disabled><link rel="stylesheet" href="../../../light.css" id="themeStyle"><script id="default-settings" ></script><script src="../../../storage.js"></script><script defer src="../../../source-script.js"></script><script defer src="../../../source-files.js"></script><script defer src="../../../main.js"></script><noscript><link rel="stylesheet" href="../../../noscript.css"></noscript><link rel="alternate icon" type="image/png" href="../../../favicon-16x16.png"><link rel="alternate icon" type="image/png" href="../../../favicon-32x32.png"><link rel="icon" type="image/svg+xml" href="../../../favicon.svg"></head><body class="rustdoc source"><!--[if lte IE 11]><div class="warning">This old browser is unsupported and will most likely display funky things.</div><![endif]--><nav class="sidebar"><a class="sidebar-logo" href="../../../memchr/index.html"><div class="logo-container"><img class="rust-logo" src="../../../rust-logo.svg" alt="logo"></div></a></nav><main><div class="width-limiter"><nav class="sub"><a class="sub-logo-container" href="../../../memchr/index.html"><img class="rust-logo" src="../../../rust-logo.svg" alt="logo"></a><form class="search-form"><div class="search-container"><span></span><input class="search-input" name="search" autocomplete="off" spellcheck="false" placeholder="Click or press ‘S’ to search, ‘?’ for more options…" type="search"><div id="help-button" title="help" tabindex="-1"><a href="../../../help.html">?</a></div><div id="settings-menu" tabindex="-1"><a href="../../../settings.html" title="settings"><img width="22" height="22" alt="Change settings" src="../../../wheel.svg"></a></div></div></form></nav><section id="main-content" class="content"><div class="example-wrap"><pre class="src-line-numbers"><span id="1">1</span>
 <span id="2">2</span>
 <span id="3">3</span>
 <span id="4">4</span>
 <span id="5">5</span>
 <span id="6">6</span>
 <span id="7">7</span>
 <span id="8">8</span>
 <span id="9">9</span>
 <span id="10">10</span>
 <span id="11">11</span>
 <span id="12">12</span>
 <span id="13">13</span>
 <span id="14">14</span>
 <span id="15">15</span>
 <span id="16">16</span>
 <span id="17">17</span>
 <span id="18">18</span>
 <span id="19">19</span>
 <span id="20">20</span>
 <span id="21">21</span>
 <span id="22">22</span>
 <span id="23">23</span>
 <span id="24">24</span>
 <span id="25">25</span>
 <span id="26">26</span>
 <span id="27">27</span>
 <span id="28">28</span>
 <span id="29">29</span>
 <span id="30">30</span>
 <span id="31">31</span>
 <span id="32">32</span>
 <span id="33">33</span>
 <span id="34">34</span>
 <span id="35">35</span>
 <span id="36">36</span>
 <span id="37">37</span>
 <span id="38">38</span>
 <span id="39">39</span>
 <span id="40">40</span>
 <span id="41">41</span>
 <span id="42">42</span>
 <span id="43">43</span>
 <span id="44">44</span>
 <span id="45">45</span>
 <span id="46">46</span>
 <span id="47">47</span>
 <span id="48">48</span>
 <span id="49">49</span>
 <span id="50">50</span>
 <span id="51">51</span>
 <span id="52">52</span>
 <span id="53">53</span>
 <span id="54">54</span>
 <span id="55">55</span>
 <span id="56">56</span>
 <span id="57">57</span>
 <span id="58">58</span>
 <span id="59">59</span>
 <span id="60">60</span>
 <span id="61">61</span>
 <span id="62">62</span>
 <span id="63">63</span>
 <span id="64">64</span>
 <span id="65">65</span>
 <span id="66">66</span>
 <span id="67">67</span>
 <span id="68">68</span>
 <span id="69">69</span>
 <span id="70">70</span>
 <span id="71">71</span>
 <span id="72">72</span>
 <span id="73">73</span>
 <span id="74">74</span>
 <span id="75">75</span>
 <span id="76">76</span>
 <span id="77">77</span>
 <span id="78">78</span>
 <span id="79">79</span>
 <span id="80">80</span>
 <span id="81">81</span>
 <span id="82">82</span>
 <span id="83">83</span>
 <span id="84">84</span>
 <span id="85">85</span>
 <span id="86">86</span>
 <span id="87">87</span>
 <span id="88">88</span>
 <span id="89">89</span>
 <span id="90">90</span>
 <span id="91">91</span>
 <span id="92">92</span>
 <span id="93">93</span>
 <span id="94">94</span>
 <span id="95">95</span>
 <span id="96">96</span>
 <span id="97">97</span>
 <span id="98">98</span>
 <span id="99">99</span>
 <span id="100">100</span>
 <span id="101">101</span>
 <span id="102">102</span>
 <span id="103">103</span>
 <span id="104">104</span>
 <span id="105">105</span>
 <span id="106">106</span>
 <span id="107">107</span>
 <span id="108">108</span>
 <span id="109">109</span>
 <span id="110">110</span>
 <span id="111">111</span>
 <span id="112">112</span>
 <span id="113">113</span>
 <span id="114">114</span>
 <span id="115">115</span>
 <span id="116">116</span>
 <span id="117">117</span>
 <span id="118">118</span>
 <span id="119">119</span>
 <span id="120">120</span>
 <span id="121">121</span>
 <span id="122">122</span>
 <span id="123">123</span>
 <span id="124">124</span>
 <span id="125">125</span>
 <span id="126">126</span>
 <span id="127">127</span>
 <span id="128">128</span>
 <span id="129">129</span>
 <span id="130">130</span>
 <span id="131">131</span>
 <span id="132">132</span>
 <span id="133">133</span>
 <span id="134">134</span>
 <span id="135">135</span>
 <span id="136">136</span>
 <span id="137">137</span>
 <span id="138">138</span>
 <span id="139">139</span>
 <span id="140">140</span>
 <span id="141">141</span>
 <span id="142">142</span>
 <span id="143">143</span>
 <span id="144">144</span>
 <span id="145">145</span>
 <span id="146">146</span>
 <span id="147">147</span>
 <span id="148">148</span>
 <span id="149">149</span>
 <span id="150">150</span>
 <span id="151">151</span>
 <span id="152">152</span>
 <span id="153">153</span>
 <span id="154">154</span>
 <span id="155">155</span>
 <span id="156">156</span>
 <span id="157">157</span>
 <span id="158">158</span>
 <span id="159">159</span>
 <span id="160">160</span>
 <span id="161">161</span>
 <span id="162">162</span>
 <span id="163">163</span>
 <span id="164">164</span>
 <span id="165">165</span>
 <span id="166">166</span>
 <span id="167">167</span>
 <span id="168">168</span>
 <span id="169">169</span>
 <span id="170">170</span>
 <span id="171">171</span>
 <span id="172">172</span>
 <span id="173">173</span>
 <span id="174">174</span>
 <span id="175">175</span>
 <span id="176">176</span>
 <span id="177">177</span>
 <span id="178">178</span>
 <span id="179">179</span>
 <span id="180">180</span>
 <span id="181">181</span>
 <span id="182">182</span>
 <span id="183">183</span>
 <span id="184">184</span>
 <span id="185">185</span>
 <span id="186">186</span>
 <span id="187">187</span>
 <span id="188">188</span>
 <span id="189">189</span>
 <span id="190">190</span>
 <span id="191">191</span>
 <span id="192">192</span>
 <span id="193">193</span>
 <span id="194">194</span>
 <span id="195">195</span>
 <span id="196">196</span>
 <span id="197">197</span>
 <span id="198">198</span>
 <span id="199">199</span>
 <span id="200">200</span>
 <span id="201">201</span>
 <span id="202">202</span>
 <span id="203">203</span>
 <span id="204">204</span>
 <span id="205">205</span>
 <span id="206">206</span>
 <span id="207">207</span>
 <span id="208">208</span>
 <span id="209">209</span>
 <span id="210">210</span>
 <span id="211">211</span>
 <span id="212">212</span>
 <span id="213">213</span>
 <span id="214">214</span>
 <span id="215">215</span>
 <span id="216">216</span>
 <span id="217">217</span>
 <span id="218">218</span>
 <span id="219">219</span>
 <span id="220">220</span>
 <span id="221">221</span>
 <span id="222">222</span>
 <span id="223">223</span>
 <span id="224">224</span>
 <span id="225">225</span>
 <span id="226">226</span>
 <span id="227">227</span>
 <span id="228">228</span>
 <span id="229">229</span>
 <span id="230">230</span>
 <span id="231">231</span>
 <span id="232">232</span>
 <span id="233">233</span>
 <span id="234">234</span>
 <span id="235">235</span>
 <span id="236">236</span>
 <span id="237">237</span>
 <span id="238">238</span>
 <span id="239">239</span>
 <span id="240">240</span>
 <span id="241">241</span>
 <span id="242">242</span>
 <span id="243">243</span>
 <span id="244">244</span>
 <span id="245">245</span>
 <span id="246">246</span>
 <span id="247">247</span>
 <span id="248">248</span>
 <span id="249">249</span>
 <span id="250">250</span>
 <span id="251">251</span>
 <span id="252">252</span>
 <span id="253">253</span>
 <span id="254">254</span>
 <span id="255">255</span>
 <span id="256">256</span>
 <span id="257">257</span>
 <span id="258">258</span>
 <span id="259">259</span>
 <span id="260">260</span>
 <span id="261">261</span>
 <span id="262">262</span>
 <span id="263">263</span>
 <span id="264">264</span>
 <span id="265">265</span>
 <span id="266">266</span>
 <span id="267">267</span>
 <span id="268">268</span>
 <span id="269">269</span>
 <span id="270">270</span>
 <span id="271">271</span>
 <span id="272">272</span>
 <span id="273">273</span>
 <span id="274">274</span>
 <span id="275">275</span>
 <span id="276">276</span>
 <span id="277">277</span>
 <span id="278">278</span>
 <span id="279">279</span>
 <span id="280">280</span>
 <span id="281">281</span>
 <span id="282">282</span>
 <span id="283">283</span>
 <span id="284">284</span>
 <span id="285">285</span>
 <span id="286">286</span>
 <span id="287">287</span>
 <span id="288">288</span>
 <span id="289">289</span>
 <span id="290">290</span>
 <span id="291">291</span>
 <span id="292">292</span>
 <span id="293">293</span>
 <span id="294">294</span>
 <span id="295">295</span>
 <span id="296">296</span>
 <span id="297">297</span>
 <span id="298">298</span>
 <span id="299">299</span>
 <span id="300">300</span>
 <span id="301">301</span>
 <span id="302">302</span>
 <span id="303">303</span>
 <span id="304">304</span>
 <span id="305">305</span>
 <span id="306">306</span>
 <span id="307">307</span>
 <span id="308">308</span>
 <span id="309">309</span>
 <span id="310">310</span>
 <span id="311">311</span>
 <span id="312">312</span>
 <span id="313">313</span>
 <span id="314">314</span>
 <span id="315">315</span>
 <span id="316">316</span>
 <span id="317">317</span>
 <span id="318">318</span>
 <span id="319">319</span>
 <span id="320">320</span>
 <span id="321">321</span>
 <span id="322">322</span>
 <span id="323">323</span>
 <span id="324">324</span>
 <span id="325">325</span>
 <span id="326">326</span>
 <span id="327">327</span>
 <span id="328">328</span>
 <span id="329">329</span>
 <span id="330">330</span>
 <span id="331">331</span>
 <span id="332">332</span>
 <span id="333">333</span>
 <span id="334">334</span>
 <span id="335">335</span>
 <span id="336">336</span>
 <span id="337">337</span>
 <span id="338">338</span>
 <span id="339">339</span>
 <span id="340">340</span>
 <span id="341">341</span>
 <span id="342">342</span>
 <span id="343">343</span>
 <span id="344">344</span>
 <span id="345">345</span>
 <span id="346">346</span>
 <span id="347">347</span>
 <span id="348">348</span>
 <span id="349">349</span>
 <span id="350">350</span>
 <span id="351">351</span>
 <span id="352">352</span>
 <span id="353">353</span>
 <span id="354">354</span>
 <span id="355">355</span>
 <span id="356">356</span>
 <span id="357">357</span>
 <span id="358">358</span>
 <span id="359">359</span>
 <span id="360">360</span>
 <span id="361">361</span>
 <span id="362">362</span>
 <span id="363">363</span>
 <span id="364">364</span>
 <span id="365">365</span>
 <span id="366">366</span>
 <span id="367">367</span>
 <span id="368">368</span>
 <span id="369">369</span>
 <span id="370">370</span>
 <span id="371">371</span>
 <span id="372">372</span>
 <span id="373">373</span>
 <span id="374">374</span>
 <span id="375">375</span>
 <span id="376">376</span>
 <span id="377">377</span>
 <span id="378">378</span>
 <span id="379">379</span>
 <span id="380">380</span>
 <span id="381">381</span>
 <span id="382">382</span>
 <span id="383">383</span>
 <span id="384">384</span>
 <span id="385">385</span>
 <span id="386">386</span>
 <span id="387">387</span>
 <span id="388">388</span>
 <span id="389">389</span>
 <span id="390">390</span>
 <span id="391">391</span>
 <span id="392">392</span>
 <span id="393">393</span>
 <span id="394">394</span>
 <span id="395">395</span>
 <span id="396">396</span>
 <span id="397">397</span>
 <span id="398">398</span>
 <span id="399">399</span>
 <span id="400">400</span>
 <span id="401">401</span>
 <span id="402">402</span>
 <span id="403">403</span>
 <span id="404">404</span>
 <span id="405">405</span>
 <span id="406">406</span>
 <span id="407">407</span>
 <span id="408">408</span>
 <span id="409">409</span>
 <span id="410">410</span>
 <span id="411">411</span>
 <span id="412">412</span>
 <span id="413">413</span>
 <span id="414">414</span>
 <span id="415">415</span>
 <span id="416">416</span>
 <span id="417">417</span>
 <span id="418">418</span>
 <span id="419">419</span>
 <span id="420">420</span>
 <span id="421">421</span>
 <span id="422">422</span>
 <span id="423">423</span>
 <span id="424">424</span>
 <span id="425">425</span>
 <span id="426">426</span>
 <span id="427">427</span>
 <span id="428">428</span>
 <span id="429">429</span>
 <span id="430">430</span>
 <span id="431">431</span>
 <span id="432">432</span>
 <span id="433">433</span>
 <span id="434">434</span>
 <span id="435">435</span>
 <span id="436">436</span>
 <span id="437">437</span>
 <span id="438">438</span>
 <span id="439">439</span>
 <span id="440">440</span>
 <span id="441">441</span>
 <span id="442">442</span>
 <span id="443">443</span>
 <span id="444">444</span>
 <span id="445">445</span>
 <span id="446">446</span>
 <span id="447">447</span>
 <span id="448">448</span>
 <span id="449">449</span>
 <span id="450">450</span>
 <span id="451">451</span>
 <span id="452">452</span>
 <span id="453">453</span>
 <span id="454">454</span>
 <span id="455">455</span>
 <span id="456">456</span>
 <span id="457">457</span>
 <span id="458">458</span>
 <span id="459">459</span>
 <span id="460">460</span>
 <span id="461">461</span>
 <span id="462">462</span>
 <span id="463">463</span>
 <span id="464">464</span>
 <span id="465">465</span>
 <span id="466">466</span>
 <span id="467">467</span>
 <span id="468">468</span>
 <span id="469">469</span>
 <span id="470">470</span>
 <span id="471">471</span>
 <span id="472">472</span>
 <span id="473">473</span>
 <span id="474">474</span>
 <span id="475">475</span>
 <span id="476">476</span>
 <span id="477">477</span>
 <span id="478">478</span>
 <span id="479">479</span>
 <span id="480">480</span>
 <span id="481">481</span>
 <span id="482">482</span>
 <span id="483">483</span>
 <span id="484">484</span>
 <span id="485">485</span>
 <span id="486">486</span>
 <span id="487">487</span>
 <span id="488">488</span>
 <span id="489">489</span>
 <span id="490">490</span>
 <span id="491">491</span>
 <span id="492">492</span>
 <span id="493">493</span>
 <span id="494">494</span>
 <span id="495">495</span>
 <span id="496">496</span>
 <span id="497">497</span>
 <span id="498">498</span>
 <span id="499">499</span>
 <span id="500">500</span>
 <span id="501">501</span>
 <span id="502">502</span>
 <span id="503">503</span>
 <span id="504">504</span>
 <span id="505">505</span>
 <span id="506">506</span>
 <span id="507">507</span>
 <span id="508">508</span>
 <span id="509">509</span>
 <span id="510">510</span>
 <span id="511">511</span>
 <span id="512">512</span>
 <span id="513">513</span>
 <span id="514">514</span>
 <span id="515">515</span>
 <span id="516">516</span>
 <span id="517">517</span>
 <span id="518">518</span>
 <span id="519">519</span>
 <span id="520">520</span>
 <span id="521">521</span>
 <span id="522">522</span>
 <span id="523">523</span>
 <span id="524">524</span>
 <span id="525">525</span>
 <span id="526">526</span>
 <span id="527">527</span>
 <span id="528">528</span>
 <span id="529">529</span>
 <span id="530">530</span>
 <span id="531">531</span>
 <span id="532">532</span>
 <span id="533">533</span>
 <span id="534">534</span>
 <span id="535">535</span>
 <span id="536">536</span>
 <span id="537">537</span>
 <span id="538">538</span>
 <span id="539">539</span>
 <span id="540">540</span>
 <span id="541">541</span>
 <span id="542">542</span>
 <span id="543">543</span>
 <span id="544">544</span>
 <span id="545">545</span>
 <span id="546">546</span>
 <span id="547">547</span>
 <span id="548">548</span>
 <span id="549">549</span>
 <span id="550">550</span>
 <span id="551">551</span>
 <span id="552">552</span>
 <span id="553">553</span>
 <span id="554">554</span>
 <span id="555">555</span>
 <span id="556">556</span>
 <span id="557">557</span>
 <span id="558">558</span>
 <span id="559">559</span>
 <span id="560">560</span>
 <span id="561">561</span>
 <span id="562">562</span>
 <span id="563">563</span>
 <span id="564">564</span>
 <span id="565">565</span>
 <span id="566">566</span>
 <span id="567">567</span>
 <span id="568">568</span>
 <span id="569">569</span>
 <span id="570">570</span>
 <span id="571">571</span>
 <span id="572">572</span>
 <span id="573">573</span>
 <span id="574">574</span>
 <span id="575">575</span>
 <span id="576">576</span>
 <span id="577">577</span>
 <span id="578">578</span>
 <span id="579">579</span>
 <span id="580">580</span>
 <span id="581">581</span>
 <span id="582">582</span>
 <span id="583">583</span>
 <span id="584">584</span>
 <span id="585">585</span>
 <span id="586">586</span>
 <span id="587">587</span>
 <span id="588">588</span>
 <span id="589">589</span>
 <span id="590">590</span>
 <span id="591">591</span>
 <span id="592">592</span>
 <span id="593">593</span>
 <span id="594">594</span>
 <span id="595">595</span>
 <span id="596">596</span>
 <span id="597">597</span>
 <span id="598">598</span>
 <span id="599">599</span>
 <span id="600">600</span>
 <span id="601">601</span>
 <span id="602">602</span>
 <span id="603">603</span>
 <span id="604">604</span>
 <span id="605">605</span>
 <span id="606">606</span>
 <span id="607">607</span>
 <span id="608">608</span>
 <span id="609">609</span>
 <span id="610">610</span>
 <span id="611">611</span>
 <span id="612">612</span>
 <span id="613">613</span>
 <span id="614">614</span>
 <span id="615">615</span>
 <span id="616">616</span>
 <span id="617">617</span>
 <span id="618">618</span>
 <span id="619">619</span>
 <span id="620">620</span>
 <span id="621">621</span>
 <span id="622">622</span>
 <span id="623">623</span>
 <span id="624">624</span>
 <span id="625">625</span>
 <span id="626">626</span>
 <span id="627">627</span>
 <span id="628">628</span>
 <span id="629">629</span>
 <span id="630">630</span>
 <span id="631">631</span>
 <span id="632">632</span>
 <span id="633">633</span>
 <span id="634">634</span>
 <span id="635">635</span>
 <span id="636">636</span>
 <span id="637">637</span>
 <span id="638">638</span>
 <span id="639">639</span>
 <span id="640">640</span>
 <span id="641">641</span>
 <span id="642">642</span>
 <span id="643">643</span>
 <span id="644">644</span>
 <span id="645">645</span>
 <span id="646">646</span>
 <span id="647">647</span>
 <span id="648">648</span>
 <span id="649">649</span>
 <span id="650">650</span>
 <span id="651">651</span>
 <span id="652">652</span>
 <span id="653">653</span>
 <span id="654">654</span>
 <span id="655">655</span>
 <span id="656">656</span>
 <span id="657">657</span>
 <span id="658">658</span>
 <span id="659">659</span>
 <span id="660">660</span>
 <span id="661">661</span>
 <span id="662">662</span>
 <span id="663">663</span>
 <span id="664">664</span>
 <span id="665">665</span>
 <span id="666">666</span>
 <span id="667">667</span>
 <span id="668">668</span>
 <span id="669">669</span>
 <span id="670">670</span>
 <span id="671">671</span>
 <span id="672">672</span>
 <span id="673">673</span>
 <span id="674">674</span>
 <span id="675">675</span>
 <span id="676">676</span>
 <span id="677">677</span>
 <span id="678">678</span>
 <span id="679">679</span>
 <span id="680">680</span>
 <span id="681">681</span>
 <span id="682">682</span>
 <span id="683">683</span>
 <span id="684">684</span>
 <span id="685">685</span>
 <span id="686">686</span>
 <span id="687">687</span>
 <span id="688">688</span>
 <span id="689">689</span>
 <span id="690">690</span>
 <span id="691">691</span>
 <span id="692">692</span>
 <span id="693">693</span>
 <span id="694">694</span>
 <span id="695">695</span>
 <span id="696">696</span>
 <span id="697">697</span>
 <span id="698">698</span>
 <span id="699">699</span>
 <span id="700">700</span>
 <span id="701">701</span>
 <span id="702">702</span>
 <span id="703">703</span>
 <span id="704">704</span>
 <span id="705">705</span>
 <span id="706">706</span>
 <span id="707">707</span>
 <span id="708">708</span>
 <span id="709">709</span>
 <span id="710">710</span>
 <span id="711">711</span>
 <span id="712">712</span>
 <span id="713">713</span>
 <span id="714">714</span>
 <span id="715">715</span>
 <span id="716">716</span>
 <span id="717">717</span>
 <span id="718">718</span>
 <span id="719">719</span>
 <span id="720">720</span>
 <span id="721">721</span>
 <span id="722">722</span>
 <span id="723">723</span>
 <span id="724">724</span>
 <span id="725">725</span>
 <span id="726">726</span>
 <span id="727">727</span>
 <span id="728">728</span>
 <span id="729">729</span>
 <span id="730">730</span>
 <span id="731">731</span>
 <span id="732">732</span>
 <span id="733">733</span>
 <span id="734">734</span>
 <span id="735">735</span>
 <span id="736">736</span>
 <span id="737">737</span>
 <span id="738">738</span>
 <span id="739">739</span>
 <span id="740">740</span>
 <span id="741">741</span>
 <span id="742">742</span>
 <span id="743">743</span>
 <span id="744">744</span>
 <span id="745">745</span>
 <span id="746">746</span>
 <span id="747">747</span>
 <span id="748">748</span>
 <span id="749">749</span>
 <span id="750">750</span>
 <span id="751">751</span>
 <span id="752">752</span>
 <span id="753">753</span>
 <span id="754">754</span>
 <span id="755">755</span>
 <span id="756">756</span>
 <span id="757">757</span>
 <span id="758">758</span>
 <span id="759">759</span>
 <span id="760">760</span>
 <span id="761">761</span>
 <span id="762">762</span>
 <span id="763">763</span>
 <span id="764">764</span>
 <span id="765">765</span>
 <span id="766">766</span>
 <span id="767">767</span>
 <span id="768">768</span>
 <span id="769">769</span>
 <span id="770">770</span>
 <span id="771">771</span>
 <span id="772">772</span>
 <span id="773">773</span>
 <span id="774">774</span>
 <span id="775">775</span>
 <span id="776">776</span>
 <span id="777">777</span>
 <span id="778">778</span>
 <span id="779">779</span>
 <span id="780">780</span>
 <span id="781">781</span>
 <span id="782">782</span>
 <span id="783">783</span>
 <span id="784">784</span>
 <span id="785">785</span>
 <span id="786">786</span>
 <span id="787">787</span>
 <span id="788">788</span>
 <span id="789">789</span>
 <span id="790">790</span>
 <span id="791">791</span>
 <span id="792">792</span>
 <span id="793">793</span>
 <span id="794">794</span>
 <span id="795">795</span>
 <span id="796">796</span>
 <span id="797">797</span>
 <span id="798">798</span>
 <span id="799">799</span>
 <span id="800">800</span>
 <span id="801">801</span>
 <span id="802">802</span>
 <span id="803">803</span>
 <span id="804">804</span>
 <span id="805">805</span>
 <span id="806">806</span>
 <span id="807">807</span>
 <span id="808">808</span>
 <span id="809">809</span>
 <span id="810">810</span>
 <span id="811">811</span>
 <span id="812">812</span>
 <span id="813">813</span>
 <span id="814">814</span>
 <span id="815">815</span>
 <span id="816">816</span>
 <span id="817">817</span>
 <span id="818">818</span>
 <span id="819">819</span>
 <span id="820">820</span>
 <span id="821">821</span>
 <span id="822">822</span>
 <span id="823">823</span>
 <span id="824">824</span>
 <span id="825">825</span>
 <span id="826">826</span>
 <span id="827">827</span>
 <span id="828">828</span>
 <span id="829">829</span>
 <span id="830">830</span>
 <span id="831">831</span>
 <span id="832">832</span>
 <span id="833">833</span>
 <span id="834">834</span>
 <span id="835">835</span>
 <span id="836">836</span>
 <span id="837">837</span>
 <span id="838">838</span>
 <span id="839">839</span>
 <span id="840">840</span>
 <span id="841">841</span>
 <span id="842">842</span>
 <span id="843">843</span>
 <span id="844">844</span>
 <span id="845">845</span>
 <span id="846">846</span>
 <span id="847">847</span>
 <span id="848">848</span>
 <span id="849">849</span>
 <span id="850">850</span>
 <span id="851">851</span>
 <span id="852">852</span>
 <span id="853">853</span>
 <span id="854">854</span>
 <span id="855">855</span>
 <span id="856">856</span>
 <span id="857">857</span>
 <span id="858">858</span>
 <span id="859">859</span>
 <span id="860">860</span>
 <span id="861">861</span>
 <span id="862">862</span>
 <span id="863">863</span>
 <span id="864">864</span>
 <span id="865">865</span>
 <span id="866">866</span>
 <span id="867">867</span>
 <span id="868">868</span>
 <span id="869">869</span>
 <span id="870">870</span>
 <span id="871">871</span>
 <span id="872">872</span>
 <span id="873">873</span>
 <span id="874">874</span>
 <span id="875">875</span>
 <span id="876">876</span>
 <span id="877">877</span>
 <span id="878">878</span>
 <span id="879">879</span>
 <span id="880">880</span>
 <span id="881">881</span>
 <span id="882">882</span>
 <span id="883">883</span>
 <span id="884">884</span>
 <span id="885">885</span>
 <span id="886">886</span>
 <span id="887">887</span>
 <span id="888">888</span>
 <span id="889">889</span>
 <span id="890">890</span>
 <span id="891">891</span>
 <span id="892">892</span>
 <span id="893">893</span>
 <span id="894">894</span>
 <span id="895">895</span>
 <span id="896">896</span>
 <span id="897">897</span>
 <span id="898">898</span>
 <span id="899">899</span>
 <span id="900">900</span>
 <span id="901">901</span>
 <span id="902">902</span>
 <span id="903">903</span>
 <span id="904">904</span>
 <span id="905">905</span>
 <span id="906">906</span>
 <span id="907">907</span>
 <span id="908">908</span>
 <span id="909">909</span>
 <span id="910">910</span>
 <span id="911">911</span>
 <span id="912">912</span>
 <span id="913">913</span>
 <span id="914">914</span>
 <span id="915">915</span>
 <span id="916">916</span>
 <span id="917">917</span>
 <span id="918">918</span>
 <span id="919">919</span>
 <span id="920">920</span>
 <span id="921">921</span>
 <span id="922">922</span>
 <span id="923">923</span>
 <span id="924">924</span>
 <span id="925">925</span>
 <span id="926">926</span>
 <span id="927">927</span>
 <span id="928">928</span>
 <span id="929">929</span>
 <span id="930">930</span>
 <span id="931">931</span>
 <span id="932">932</span>
 <span id="933">933</span>
 <span id="934">934</span>
 <span id="935">935</span>
 <span id="936">936</span>
 <span id="937">937</span>
 <span id="938">938</span>
 <span id="939">939</span>
 <span id="940">940</span>
 <span id="941">941</span>
 <span id="942">942</span>
 <span id="943">943</span>
 <span id="944">944</span>
 <span id="945">945</span>
 <span id="946">946</span>
 <span id="947">947</span>
 <span id="948">948</span>
 <span id="949">949</span>
 <span id="950">950</span>
 <span id="951">951</span>
 <span id="952">952</span>
 <span id="953">953</span>
 <span id="954">954</span>
 <span id="955">955</span>
 <span id="956">956</span>
 <span id="957">957</span>
 <span id="958">958</span>
 <span id="959">959</span>
 <span id="960">960</span>
 <span id="961">961</span>
 <span id="962">962</span>
 <span id="963">963</span>
 <span id="964">964</span>
 <span id="965">965</span>
 <span id="966">966</span>
 <span id="967">967</span>
 <span id="968">968</span>
 <span id="969">969</span>
 <span id="970">970</span>
 <span id="971">971</span>
 <span id="972">972</span>
 <span id="973">973</span>
 <span id="974">974</span>
 <span id="975">975</span>
 <span id="976">976</span>
 <span id="977">977</span>
 <span id="978">978</span>
 <span id="979">979</span>
 <span id="980">980</span>
 <span id="981">981</span>
 <span id="982">982</span>
 <span id="983">983</span>
 <span id="984">984</span>
 <span id="985">985</span>
 <span id="986">986</span>
 <span id="987">987</span>
 <span id="988">988</span>
 <span id="989">989</span>
 <span id="990">990</span>
 <span id="991">991</span>
 <span id="992">992</span>
 <span id="993">993</span>
 <span id="994">994</span>
 <span id="995">995</span>
 <span id="996">996</span>
 <span id="997">997</span>
 <span id="998">998</span>
 <span id="999">999</span>
 <span id="1000">1000</span>
 <span id="1001">1001</span>
 <span id="1002">1002</span>
 <span id="1003">1003</span>
 <span id="1004">1004</span>
 <span id="1005">1005</span>
 <span id="1006">1006</span>
 <span id="1007">1007</span>
 <span id="1008">1008</span>
 <span id="1009">1009</span>
 <span id="1010">1010</span>
 <span id="1011">1011</span>
 <span id="1012">1012</span>
 <span id="1013">1013</span>
 <span id="1014">1014</span>
 <span id="1015">1015</span>
 <span id="1016">1016</span>
 <span id="1017">1017</span>
 <span id="1018">1018</span>
 <span id="1019">1019</span>
 <span id="1020">1020</span>
 <span id="1021">1021</span>
 <span id="1022">1022</span>
 <span id="1023">1023</span>
 <span id="1024">1024</span>
 <span id="1025">1025</span>
 <span id="1026">1026</span>
 <span id="1027">1027</span>
 <span id="1028">1028</span>
 <span id="1029">1029</span>
 <span id="1030">1030</span>
 <span id="1031">1031</span>
 <span id="1032">1032</span>
 <span id="1033">1033</span>
 <span id="1034">1034</span>
 <span id="1035">1035</span>
 <span id="1036">1036</span>
 <span id="1037">1037</span>
 <span id="1038">1038</span>
 <span id="1039">1039</span>
 <span id="1040">1040</span>
 <span id="1041">1041</span>
 <span id="1042">1042</span>
 <span id="1043">1043</span>
 <span id="1044">1044</span>
 <span id="1045">1045</span>
 <span id="1046">1046</span>
 <span id="1047">1047</span>
 <span id="1048">1048</span>
 <span id="1049">1049</span>
 <span id="1050">1050</span>
 <span id="1051">1051</span>
 <span id="1052">1052</span>
 <span id="1053">1053</span>
 <span id="1054">1054</span>
 <span id="1055">1055</span>
 <span id="1056">1056</span>
 <span id="1057">1057</span>
 <span id="1058">1058</span>
 <span id="1059">1059</span>
 <span id="1060">1060</span>
 <span id="1061">1061</span>
 <span id="1062">1062</span>
 <span id="1063">1063</span>
 <span id="1064">1064</span>
 <span id="1065">1065</span>
 <span id="1066">1066</span>
 <span id="1067">1067</span>
 <span id="1068">1068</span>
 <span id="1069">1069</span>
 <span id="1070">1070</span>
 <span id="1071">1071</span>
 <span id="1072">1072</span>
 <span id="1073">1073</span>
 <span id="1074">1074</span>
 <span id="1075">1075</span>
 <span id="1076">1076</span>
 <span id="1077">1077</span>
 <span id="1078">1078</span>
 <span id="1079">1079</span>
 <span id="1080">1080</span>
 <span id="1081">1081</span>
 <span id="1082">1082</span>
 <span id="1083">1083</span>
 <span id="1084">1084</span>
 <span id="1085">1085</span>
 <span id="1086">1086</span>
 <span id="1087">1087</span>
 <span id="1088">1088</span>
 <span id="1089">1089</span>
 <span id="1090">1090</span>
 <span id="1091">1091</span>
 <span id="1092">1092</span>
 <span id="1093">1093</span>
 <span id="1094">1094</span>
 <span id="1095">1095</span>
 <span id="1096">1096</span>
 <span id="1097">1097</span>
 <span id="1098">1098</span>
 <span id="1099">1099</span>
 <span id="1100">1100</span>
 <span id="1101">1101</span>
 <span id="1102">1102</span>
 <span id="1103">1103</span>
 <span id="1104">1104</span>
 <span id="1105">1105</span>
 <span id="1106">1106</span>
 <span id="1107">1107</span>
 <span id="1108">1108</span>
 <span id="1109">1109</span>
 <span id="1110">1110</span>
 <span id="1111">1111</span>
 <span id="1112">1112</span>
 <span id="1113">1113</span>
 <span id="1114">1114</span>
 <span id="1115">1115</span>
 <span id="1116">1116</span>
 <span id="1117">1117</span>
 <span id="1118">1118</span>
 <span id="1119">1119</span>
 <span id="1120">1120</span>
 <span id="1121">1121</span>
 <span id="1122">1122</span>
 <span id="1123">1123</span>
 <span id="1124">1124</span>
 <span id="1125">1125</span>
 <span id="1126">1126</span>
 <span id="1127">1127</span>
 <span id="1128">1128</span>
 <span id="1129">1129</span>
 <span id="1130">1130</span>
 <span id="1131">1131</span>
 <span id="1132">1132</span>
 <span id="1133">1133</span>
 <span id="1134">1134</span>
 <span id="1135">1135</span>
 <span id="1136">1136</span>
 <span id="1137">1137</span>
 <span id="1138">1138</span>
 <span id="1139">1139</span>
 <span id="1140">1140</span>
 <span id="1141">1141</span>
 <span id="1142">1142</span>
 <span id="1143">1143</span>
 <span id="1144">1144</span>
 <span id="1145">1145</span>
 <span id="1146">1146</span>
 <span id="1147">1147</span>
 <span id="1148">1148</span>
 <span id="1149">1149</span>
 <span id="1150">1150</span>
 <span id="1151">1151</span>
 <span id="1152">1152</span>
 <span id="1153">1153</span>
 <span id="1154">1154</span>
 <span id="1155">1155</span>
 <span id="1156">1156</span>
 <span id="1157">1157</span>
 <span id="1158">1158</span>
 <span id="1159">1159</span>
 <span id="1160">1160</span>
 <span id="1161">1161</span>
 <span id="1162">1162</span>
 <span id="1163">1163</span>
 <span id="1164">1164</span>
 <span id="1165">1165</span>
 <span id="1166">1166</span>
 <span id="1167">1167</span>
 <span id="1168">1168</span>
 <span id="1169">1169</span>
 <span id="1170">1170</span>
 <span id="1171">1171</span>
 <span id="1172">1172</span>
 <span id="1173">1173</span>
 <span id="1174">1174</span>
 <span id="1175">1175</span>
 <span id="1176">1176</span>
 <span id="1177">1177</span>
 <span id="1178">1178</span>
 <span id="1179">1179</span>
 <span id="1180">1180</span>
 <span id="1181">1181</span>
 <span id="1182">1182</span>
 <span id="1183">1183</span>
 <span id="1184">1184</span>
 <span id="1185">1185</span>
 <span id="1186">1186</span>
 <span id="1187">1187</span>
 <span id="1188">1188</span>
 <span id="1189">1189</span>
 <span id="1190">1190</span>
 <span id="1191">1191</span>
 <span id="1192">1192</span>
 <span id="1193">1193</span>
 <span id="1194">1194</span>
 <span id="1195">1195</span>
 <span id="1196">1196</span>
 <span id="1197">1197</span>
 <span id="1198">1198</span>
 <span id="1199">1199</span>
 <span id="1200">1200</span>
 <span id="1201">1201</span>
 <span id="1202">1202</span>
 <span id="1203">1203</span>
 <span id="1204">1204</span>
 <span id="1205">1205</span>
 <span id="1206">1206</span>
 <span id="1207">1207</span>
 <span id="1208">1208</span>
 <span id="1209">1209</span>
 <span id="1210">1210</span>
 <span id="1211">1211</span>
 <span id="1212">1212</span>
 <span id="1213">1213</span>
 <span id="1214">1214</span>
 <span id="1215">1215</span>
 <span id="1216">1216</span>
 <span id="1217">1217</span>
 <span id="1218">1218</span>
 <span id="1219">1219</span>
 <span id="1220">1220</span>
 <span id="1221">1221</span>
 <span id="1222">1222</span>
 <span id="1223">1223</span>
 <span id="1224">1224</span>
 <span id="1225">1225</span>
 <span id="1226">1226</span>
 <span id="1227">1227</span>
 <span id="1228">1228</span>
 <span id="1229">1229</span>
 <span id="1230">1230</span>
 <span id="1231">1231</span>
 <span id="1232">1232</span>
 <span id="1233">1233</span>
 <span id="1234">1234</span>
 <span id="1235">1235</span>
 <span id="1236">1236</span>
 <span id="1237">1237</span>
 <span id="1238">1238</span>
 <span id="1239">1239</span>
 <span id="1240">1240</span>
 <span id="1241">1241</span>
 <span id="1242">1242</span>
 <span id="1243">1243</span>
 <span id="1244">1244</span>
 <span id="1245">1245</span>
 <span id="1246">1246</span>
 <span id="1247">1247</span>
 <span id="1248">1248</span>
 <span id="1249">1249</span>
 <span id="1250">1250</span>
 <span id="1251">1251</span>
 <span id="1252">1252</span>
 <span id="1253">1253</span>
 <span id="1254">1254</span>
 <span id="1255">1255</span>
 <span id="1256">1256</span>
 <span id="1257">1257</span>
 <span id="1258">1258</span>
 <span id="1259">1259</span>
 <span id="1260">1260</span>
 <span id="1261">1261</span>
 <span id="1262">1262</span>
 <span id="1263">1263</span>
 <span id="1264">1264</span>
 <span id="1265">1265</span>
 <span id="1266">1266</span>
 <span id="1267">1267</span>
 <span id="1268">1268</span>
 <span id="1269">1269</span>
 <span id="1270">1270</span>
 <span id="1271">1271</span>
 <span id="1272">1272</span>
 <span id="1273">1273</span>
 <span id="1274">1274</span>
 <span id="1275">1275</span>
 <span id="1276">1276</span>
 <span id="1277">1277</span>
 <span id="1278">1278</span>
 <span id="1279">1279</span>
 <span id="1280">1280</span>
 <span id="1281">1281</span>
 <span id="1282">1282</span>
 <span id="1283">1283</span>
 <span id="1284">1284</span>
 <span id="1285">1285</span>
 <span id="1286">1286</span>
 <span id="1287">1287</span>
 <span id="1288">1288</span>
 <span id="1289">1289</span>
 <span id="1290">1290</span>
 <span id="1291">1291</span>
 <span id="1292">1292</span>
 <span id="1293">1293</span>
 <span id="1294">1294</span>
 <span id="1295">1295</span>
 <span id="1296">1296</span>
 <span id="1297">1297</span>
 <span id="1298">1298</span>
 <span id="1299">1299</span>
 <span id="1300">1300</span>
 <span id="1301">1301</span>
 <span id="1302">1302</span>
 <span id="1303">1303</span>
 <span id="1304">1304</span>
 <span id="1305">1305</span>
 <span id="1306">1306</span>
 <span id="1307">1307</span>
 <span id="1308">1308</span>
 <span id="1309">1309</span>
 <span id="1310">1310</span>
 <span id="1311">1311</span>
 <span id="1312">1312</span>
 <span id="1313">1313</span>
 <span id="1314">1314</span>
 <span id="1315">1315</span>
 <span id="1316">1316</span>
 <span id="1317">1317</span>
 <span id="1318">1318</span>
 <span id="1319">1319</span>
 <span id="1320">1320</span>
 <span id="1321">1321</span>
 </pre><pre class="rust"><code><span class="doccomment">/*!
 This module provides forward and reverse substring search routines.

 Unlike the standard library&#39;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&quot;foo bar foo baz foo&quot;;

 let mut it = memmem::find_iter(haystack, &quot;foo&quot;);
 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&#39;t done by calling `rev` on a forward iterator.

 ```
 use memchr::memmem;

 let haystack = b&quot;foo bar foo baz foo&quot;;

 let mut it = memmem::rfind_iter(haystack, &quot;foo&quot;);
 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(&quot;foo&quot;);

 assert_eq!(Some(4), finder.find(b&quot;baz foo quux&quot;));
 assert_eq!(None, finder.find(b&quot;quux baz bar&quot;));
 ```
 */

 </span><span class="kw">pub use </span><span class="self">self</span>::prefilter::Prefilter;

 <span class="kw">use crate</span>::{
     cow::CowBytes,
     memmem::{
         prefilter::{Pre, PrefilterFn, PrefilterState},
         rabinkarp::NeedleHash,
         rarebytes::RareNeedleBytes,
     },
 };

 <span class="doccomment">/// Defines a suite of quickcheck properties for forward and reverse
 /// substring searching.
 ///
 /// This is defined in this specific spot so that it can be used freely among
 /// the different substring search implementations. I couldn&#39;t be bothered to
 /// fight with the macro-visibility rules enough to figure out how to stuff it
 /// somewhere more convenient.
 </span><span class="attribute">#[cfg(all(test, feature = <span class="string">&quot;std&quot;</span>))]
 </span><span class="macro">macro_rules! </span>define_memmem_quickcheck_tests {
     (<span class="macro-nonterminal">$fwd</span>:expr, <span class="macro-nonterminal">$rev</span>:expr) =&gt; {
         <span class="kw">use </span><span class="kw">crate</span>::memmem::proptests;

         <span class="macro">quickcheck::quickcheck! </span>{
             <span class="kw">fn </span>qc_fwd_prefix_is_substring(bs: Vec&lt;u8&gt;) -&gt; bool {
                 proptests::prefix_is_substring(<span class="bool-val">false</span>, <span class="kw-2">&amp;</span>bs, <span class="macro-nonterminal">$fwd</span>)
             }

             <span class="kw">fn </span>qc_fwd_suffix_is_substring(bs: Vec&lt;u8&gt;) -&gt; bool {
                 proptests::suffix_is_substring(<span class="bool-val">false</span>, <span class="kw-2">&amp;</span>bs, <span class="macro-nonterminal">$fwd</span>)
             }

             <span class="kw">fn </span>qc_fwd_matches_naive(
                 haystack: Vec&lt;u8&gt;,
                 needle: Vec&lt;u8&gt;
             ) -&gt; bool {
                 proptests::matches_naive(<span class="bool-val">false</span>, <span class="kw-2">&amp;</span>haystack, <span class="kw-2">&amp;</span>needle, <span class="macro-nonterminal">$fwd</span>)
             }

             <span class="kw">fn </span>qc_rev_prefix_is_substring(bs: Vec&lt;u8&gt;) -&gt; bool {
                 proptests::prefix_is_substring(<span class="bool-val">true</span>, <span class="kw-2">&amp;</span>bs, <span class="macro-nonterminal">$rev</span>)
             }

             <span class="kw">fn </span>qc_rev_suffix_is_substring(bs: Vec&lt;u8&gt;) -&gt; bool {
                 proptests::suffix_is_substring(<span class="bool-val">true</span>, <span class="kw-2">&amp;</span>bs, <span class="macro-nonterminal">$rev</span>)
             }

             <span class="kw">fn </span>qc_rev_matches_naive(
                 haystack: Vec&lt;u8&gt;,
                 needle: Vec&lt;u8&gt;
             ) -&gt; bool {
                 proptests::matches_naive(<span class="bool-val">true</span>, <span class="kw-2">&amp;</span>haystack, <span class="kw-2">&amp;</span>needle, <span class="macro-nonterminal">$rev</span>)
             }
         }
     };
 }

 <span class="doccomment">/// Defines a suite of &quot;simple&quot; hand-written tests for a substring
 /// implementation.
 ///
 /// This is defined here for the same reason that
 /// define_memmem_quickcheck_tests is defined here.
 </span><span class="attribute">#[cfg(test)]
 </span><span class="macro">macro_rules! </span>define_memmem_simple_tests {
     (<span class="macro-nonterminal">$fwd</span>:expr, <span class="macro-nonterminal">$rev</span>:expr) =&gt; {
         <span class="kw">use </span><span class="kw">crate</span>::memmem::testsimples;

         <span class="attribute">#[test]
         </span><span class="kw">fn </span>simple_forward() {
             testsimples::run_search_tests_fwd(<span class="macro-nonterminal">$fwd</span>);
         }

         <span class="attribute">#[test]
         </span><span class="kw">fn </span>simple_reverse() {
             testsimples::run_search_tests_rev(<span class="macro-nonterminal">$rev</span>);
         }
     };
 }

 <span class="kw">mod </span>byte_frequencies;
 <span class="attribute">#[cfg(memchr_runtime_simd)]
 </span><span class="kw">mod </span>genericsimd;
 <span class="kw">mod </span>prefilter;
 <span class="kw">mod </span>rabinkarp;
 <span class="kw">mod </span>rarebytes;
 <span class="kw">mod </span>twoway;
 <span class="kw">mod </span>util;
 <span class="attribute">#[cfg(memchr_runtime_simd)]
 </span><span class="kw">mod </span>vector;
 <span class="attribute">#[cfg(all(memchr_runtime_wasm128))]
 </span><span class="kw">mod </span>wasm;
 <span class="attribute">#[cfg(all(not(miri), target_arch = <span class="string">&quot;x86_64&quot;</span>, memchr_runtime_simd))]
 </span><span class="kw">mod </span>x86;

 <span class="doccomment">/// Returns an iterator over all non-overlapping occurrences of a substring in
 /// a haystack.
 ///
 /// # Complexity
 ///
 /// This routine is guaranteed to have worst case linear time complexity
 /// with respect to both the needle and the haystack. That is, this runs
 /// in `O(needle.len() + haystack.len())` time.
 ///
 /// This routine is also guaranteed to have worst case constant space
 /// complexity.
 ///
 /// # Examples
 ///
 /// Basic usage:
 ///
 /// ```
 /// use memchr::memmem;
 ///
 /// let haystack = b&quot;foo bar foo baz foo&quot;;
 /// let mut it = memmem::find_iter(haystack, b&quot;foo&quot;);
 /// assert_eq!(Some(0), it.next());
 /// assert_eq!(Some(8), it.next());
 /// assert_eq!(Some(16), it.next());
 /// assert_eq!(None, it.next());
 /// ```
 </span><span class="attribute">#[inline]
 </span><span class="kw">pub fn </span>find_iter&lt;<span class="lifetime">&#39;h</span>, <span class="lifetime">&#39;n</span>, N: <span class="lifetime">&#39;n </span>+ <span class="question-mark">?</span>Sized + AsRef&lt;[u8]&gt;&gt;(
     haystack: <span class="kw-2">&amp;</span><span class="lifetime">&#39;h </span>[u8],
     needle: <span class="kw-2">&amp;</span><span class="lifetime">&#39;n </span>N,
 ) -&gt; FindIter&lt;<span class="lifetime">&#39;h</span>, <span class="lifetime">&#39;n</span>&gt; {
     FindIter::new(haystack, Finder::new(needle))
 }

 <span class="doccomment">/// Returns a reverse iterator over all non-overlapping occurrences of a
 /// substring in a haystack.
 ///
 /// # Complexity
 ///
 /// This routine is guaranteed to have worst case linear time complexity
 /// with respect to both the needle and the haystack. That is, this runs
 /// in `O(needle.len() + haystack.len())` time.
 ///
 /// This routine is also guaranteed to have worst case constant space
 /// complexity.
 ///
 /// # Examples
 ///
 /// Basic usage:
 ///
 /// ```
 /// use memchr::memmem;
 ///
 /// let haystack = b&quot;foo bar foo baz foo&quot;;
 /// let mut it = memmem::rfind_iter(haystack, b&quot;foo&quot;);
 /// assert_eq!(Some(16), it.next());
 /// assert_eq!(Some(8), it.next());
 /// assert_eq!(Some(0), it.next());
 /// assert_eq!(None, it.next());
 /// ```
 </span><span class="attribute">#[inline]
 </span><span class="kw">pub fn </span>rfind_iter&lt;<span class="lifetime">&#39;h</span>, <span class="lifetime">&#39;n</span>, N: <span class="lifetime">&#39;n </span>+ <span class="question-mark">?</span>Sized + AsRef&lt;[u8]&gt;&gt;(
     haystack: <span class="kw-2">&amp;</span><span class="lifetime">&#39;h </span>[u8],
     needle: <span class="kw-2">&amp;</span><span class="lifetime">&#39;n </span>N,
 ) -&gt; FindRevIter&lt;<span class="lifetime">&#39;h</span>, <span class="lifetime">&#39;n</span>&gt; {
     FindRevIter::new(haystack, FinderRev::new(needle))
 }

 <span class="doccomment">/// Returns the index of the first occurrence of the given needle.
 ///
 /// Note that if you&#39;re are searching for the same needle in many different
 /// small haystacks, it may be faster to initialize a [`Finder`] once,
 /// and reuse it for each search.
 ///
 /// # Complexity
 ///
 /// This routine is guaranteed to have worst case linear time complexity
 /// with respect to both the needle and the haystack. That is, this runs
 /// in `O(needle.len() + haystack.len())` time.
 ///
 /// This routine is also guaranteed to have worst case constant space
 /// complexity.
 ///
 /// # Examples
 ///
 /// Basic usage:
 ///
 /// ```
 /// use memchr::memmem;
 ///
 /// let haystack = b&quot;foo bar baz&quot;;
 /// assert_eq!(Some(0), memmem::find(haystack, b&quot;foo&quot;));
 /// assert_eq!(Some(4), memmem::find(haystack, b&quot;bar&quot;));
 /// assert_eq!(None, memmem::find(haystack, b&quot;quux&quot;));
 /// ```
 </span><span class="attribute">#[inline]
 </span><span class="kw">pub fn </span>find(haystack: <span class="kw-2">&amp;</span>[u8], needle: <span class="kw-2">&amp;</span>[u8]) -&gt; <span class="prelude-ty">Option</span>&lt;usize&gt; {
     <span class="kw">if </span>haystack.len() &lt; <span class="number">64 </span>{
         rabinkarp::find(haystack, needle)
     } <span class="kw">else </span>{
         Finder::new(needle).find(haystack)
     }
 }

 <span class="doccomment">/// Returns the index of the last occurrence of the given needle.
 ///
 /// Note that if you&#39;re are searching for the same needle in many different
 /// small haystacks, it may be faster to initialize a [`FinderRev`] once,
 /// and reuse it for each search.
 ///
 /// # Complexity
 ///
 /// This routine is guaranteed to have worst case linear time complexity
 /// with respect to both the needle and the haystack. That is, this runs
 /// in `O(needle.len() + haystack.len())` time.
 ///
 /// This routine is also guaranteed to have worst case constant space
 /// complexity.
 ///
 /// # Examples
 ///
 /// Basic usage:
 ///
 /// ```
 /// use memchr::memmem;
 ///
 /// let haystack = b&quot;foo bar baz&quot;;
 /// assert_eq!(Some(0), memmem::rfind(haystack, b&quot;foo&quot;));
 /// assert_eq!(Some(4), memmem::rfind(haystack, b&quot;bar&quot;));
 /// assert_eq!(Some(8), memmem::rfind(haystack, b&quot;ba&quot;));
 /// assert_eq!(None, memmem::rfind(haystack, b&quot;quux&quot;));
 /// ```
 </span><span class="attribute">#[inline]
 </span><span class="kw">pub fn </span>rfind(haystack: <span class="kw-2">&amp;</span>[u8], needle: <span class="kw-2">&amp;</span>[u8]) -&gt; <span class="prelude-ty">Option</span>&lt;usize&gt; {
     <span class="kw">if </span>haystack.len() &lt; <span class="number">64 </span>{
         rabinkarp::rfind(haystack, needle)
     } <span class="kw">else </span>{
         FinderRev::new(needle).rfind(haystack)
     }
 }

 <span class="doccomment">/// An iterator over non-overlapping substring matches.
 ///
 /// Matches are reported by the byte offset at which they begin.
 ///
 /// `&#39;h` is the lifetime of the haystack while `&#39;n` is the lifetime of the
 /// needle.
 </span><span class="attribute">#[derive(Debug)]
 </span><span class="kw">pub struct </span>FindIter&lt;<span class="lifetime">&#39;h</span>, <span class="lifetime">&#39;n</span>&gt; {
     haystack: <span class="kw-2">&amp;</span><span class="lifetime">&#39;h </span>[u8],
     prestate: PrefilterState,
     finder: Finder&lt;<span class="lifetime">&#39;n</span>&gt;,
     pos: usize,
 }

 <span class="kw">impl</span>&lt;<span class="lifetime">&#39;h</span>, <span class="lifetime">&#39;n</span>&gt; FindIter&lt;<span class="lifetime">&#39;h</span>, <span class="lifetime">&#39;n</span>&gt; {
     <span class="attribute">#[inline(always)]
     </span><span class="kw">pub</span>(<span class="kw">crate</span>) <span class="kw">fn </span>new(
         haystack: <span class="kw-2">&amp;</span><span class="lifetime">&#39;h </span>[u8],
         finder: Finder&lt;<span class="lifetime">&#39;n</span>&gt;,
     ) -&gt; FindIter&lt;<span class="lifetime">&#39;h</span>, <span class="lifetime">&#39;n</span>&gt; {
         <span class="kw">let </span>prestate = finder.searcher.prefilter_state();
         FindIter { haystack, prestate, finder, pos: <span class="number">0 </span>}
     }

     <span class="doccomment">/// Convert this iterator into its owned variant, such that it no longer
     /// borrows the finder and needle.
     ///
     /// If this is already an owned iterator, then this is a no-op. Otherwise,
     /// this copies the needle.
     ///
     /// This is only available when the `std` feature is enabled.
     </span><span class="attribute">#[cfg(feature = <span class="string">&quot;std&quot;</span>)]
     #[inline]
     </span><span class="kw">pub fn </span>into_owned(<span class="self">self</span>) -&gt; FindIter&lt;<span class="lifetime">&#39;h</span>, <span class="lifetime">&#39;static</span>&gt; {
         FindIter {
             haystack: <span class="self">self</span>.haystack,
             prestate: <span class="self">self</span>.prestate,
             finder: <span class="self">self</span>.finder.into_owned(),
             pos: <span class="self">self</span>.pos,
         }
     }
 }

 <span class="kw">impl</span>&lt;<span class="lifetime">&#39;h</span>, <span class="lifetime">&#39;n</span>&gt; Iterator <span class="kw">for </span>FindIter&lt;<span class="lifetime">&#39;h</span>, <span class="lifetime">&#39;n</span>&gt; {
     <span class="kw">type </span>Item = usize;

     <span class="kw">fn </span>next(<span class="kw-2">&amp;mut </span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;usize&gt; {
         <span class="kw">if </span><span class="self">self</span>.pos &gt; <span class="self">self</span>.haystack.len() {
             <span class="kw">return </span><span class="prelude-val">None</span>;
         }
         <span class="kw">let </span>result = <span class="self">self
             </span>.finder
             .searcher
             .find(<span class="kw-2">&amp;mut </span><span class="self">self</span>.prestate, <span class="kw-2">&amp;</span><span class="self">self</span>.haystack[<span class="self">self</span>.pos..]);
         <span class="kw">match </span>result {
             <span class="prelude-val">None </span>=&gt; <span class="prelude-val">None</span>,
             <span class="prelude-val">Some</span>(i) =&gt; {
                 <span class="kw">let </span>pos = <span class="self">self</span>.pos + i;
                 <span class="self">self</span>.pos = pos + core::cmp::max(<span class="number">1</span>, <span class="self">self</span>.finder.needle().len());
                 <span class="prelude-val">Some</span>(pos)
             }
         }
     }
 }

 <span class="doccomment">/// An iterator over non-overlapping substring matches in reverse.
 ///
 /// Matches are reported by the byte offset at which they begin.
 ///
 /// `&#39;h` is the lifetime of the haystack while `&#39;n` is the lifetime of the
 /// needle.
 </span><span class="attribute">#[derive(Debug)]
 </span><span class="kw">pub struct </span>FindRevIter&lt;<span class="lifetime">&#39;h</span>, <span class="lifetime">&#39;n</span>&gt; {
     haystack: <span class="kw-2">&amp;</span><span class="lifetime">&#39;h </span>[u8],
     finder: FinderRev&lt;<span class="lifetime">&#39;n</span>&gt;,
     <span class="doccomment">/// When searching with an empty needle, this gets set to `None` after
     /// we&#39;ve yielded the last element at `0`.
     </span>pos: <span class="prelude-ty">Option</span>&lt;usize&gt;,
 }

 <span class="kw">impl</span>&lt;<span class="lifetime">&#39;h</span>, <span class="lifetime">&#39;n</span>&gt; FindRevIter&lt;<span class="lifetime">&#39;h</span>, <span class="lifetime">&#39;n</span>&gt; {
     <span class="attribute">#[inline(always)]
     </span><span class="kw">pub</span>(<span class="kw">crate</span>) <span class="kw">fn </span>new(
         haystack: <span class="kw-2">&amp;</span><span class="lifetime">&#39;h </span>[u8],
         finder: FinderRev&lt;<span class="lifetime">&#39;n</span>&gt;,
     ) -&gt; FindRevIter&lt;<span class="lifetime">&#39;h</span>, <span class="lifetime">&#39;n</span>&gt; {
         <span class="kw">let </span>pos = <span class="prelude-val">Some</span>(haystack.len());
         FindRevIter { haystack, finder, pos }
     }

     <span class="doccomment">/// Convert this iterator into its owned variant, such that it no longer
     /// borrows the finder and needle.
     ///
     /// If this is already an owned iterator, then this is a no-op. Otherwise,
     /// this copies the needle.
     ///
     /// This is only available when the `std` feature is enabled.
     </span><span class="attribute">#[cfg(feature = <span class="string">&quot;std&quot;</span>)]
     #[inline]
     </span><span class="kw">pub fn </span>into_owned(<span class="self">self</span>) -&gt; FindRevIter&lt;<span class="lifetime">&#39;h</span>, <span class="lifetime">&#39;static</span>&gt; {
         FindRevIter {
             haystack: <span class="self">self</span>.haystack,
             finder: <span class="self">self</span>.finder.into_owned(),
             pos: <span class="self">self</span>.pos,
         }
     }
 }

 <span class="kw">impl</span>&lt;<span class="lifetime">&#39;h</span>, <span class="lifetime">&#39;n</span>&gt; Iterator <span class="kw">for </span>FindRevIter&lt;<span class="lifetime">&#39;h</span>, <span class="lifetime">&#39;n</span>&gt; {
     <span class="kw">type </span>Item = usize;

     <span class="kw">fn </span>next(<span class="kw-2">&amp;mut </span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;usize&gt; {
         <span class="kw">let </span>pos = <span class="kw">match </span><span class="self">self</span>.pos {
             <span class="prelude-val">None </span>=&gt; <span class="kw">return </span><span class="prelude-val">None</span>,
             <span class="prelude-val">Some</span>(pos) =&gt; pos,
         };
         <span class="kw">let </span>result = <span class="self">self</span>.finder.rfind(<span class="kw-2">&amp;</span><span class="self">self</span>.haystack[..pos]);
         <span class="kw">match </span>result {
             <span class="prelude-val">None </span>=&gt; <span class="prelude-val">None</span>,
             <span class="prelude-val">Some</span>(i) =&gt; {
                 <span class="kw">if </span>pos == i {
                     <span class="self">self</span>.pos = pos.checked_sub(<span class="number">1</span>);
                 } <span class="kw">else </span>{
                     <span class="self">self</span>.pos = <span class="prelude-val">Some</span>(i);
                 }
                 <span class="prelude-val">Some</span>(i)
             }
         }
     }
 }

 <span class="doccomment">/// A single substring searcher fixed to a particular needle.
 ///
 /// The purpose of this type is to permit callers to construct a substring
 /// searcher that can be used to search haystacks without the overhead of
 /// constructing the searcher in the first place. This is a somewhat niche
 /// concern when it&#39;s necessary to re-use the same needle to search multiple
 /// different haystacks with as little overhead as possible. In general, using
 /// [`find`] is good enough, but `Finder` is useful when you can meaningfully
 /// observe searcher construction time in a profile.
 ///
 /// When the `std` feature is enabled, then this type has an `into_owned`
 /// version which permits building a `Finder` that is not connected to
 /// the lifetime of its needle.
 </span><span class="attribute">#[derive(Clone, Debug)]
 </span><span class="kw">pub struct </span>Finder&lt;<span class="lifetime">&#39;n</span>&gt; {
     searcher: Searcher&lt;<span class="lifetime">&#39;n</span>&gt;,
 }

 <span class="kw">impl</span>&lt;<span class="lifetime">&#39;n</span>&gt; Finder&lt;<span class="lifetime">&#39;n</span>&gt; {
     <span class="doccomment">/// Create a new finder for the given needle.
     </span><span class="attribute">#[inline]
     </span><span class="kw">pub fn </span>new&lt;B: <span class="question-mark">?</span>Sized + AsRef&lt;[u8]&gt;&gt;(needle: <span class="kw-2">&amp;</span><span class="lifetime">&#39;n </span>B) -&gt; Finder&lt;<span class="lifetime">&#39;n</span>&gt; {
         FinderBuilder::new().build_forward(needle)
     }

     <span class="doccomment">/// Returns the index of the first occurrence of this needle in the given
     /// haystack.
     ///
     /// # Complexity
     ///
     /// This routine is guaranteed to have worst case linear time complexity
     /// with respect to both the needle and the haystack. That is, this runs
     /// in `O(needle.len() + haystack.len())` time.
     ///
     /// This routine is also guaranteed to have worst case constant space
     /// complexity.
     ///
     /// # Examples
     ///
     /// Basic usage:
     ///
     /// ```
     /// use memchr::memmem::Finder;
     ///
     /// let haystack = b&quot;foo bar baz&quot;;
     /// assert_eq!(Some(0), Finder::new(&quot;foo&quot;).find(haystack));
     /// assert_eq!(Some(4), Finder::new(&quot;bar&quot;).find(haystack));
     /// assert_eq!(None, Finder::new(&quot;quux&quot;).find(haystack));
     /// ```
     </span><span class="kw">pub fn </span>find(<span class="kw-2">&amp;</span><span class="self">self</span>, haystack: <span class="kw-2">&amp;</span>[u8]) -&gt; <span class="prelude-ty">Option</span>&lt;usize&gt; {
         <span class="self">self</span>.searcher.find(<span class="kw-2">&amp;mut </span><span class="self">self</span>.searcher.prefilter_state(), haystack)
     }

     <span class="doccomment">/// Returns an iterator over all occurrences of a substring in a haystack.
     ///
     /// # Complexity
     ///
     /// This routine is guaranteed to have worst case linear time complexity
     /// with respect to both the needle and the haystack. That is, this runs
     /// in `O(needle.len() + haystack.len())` time.
     ///
     /// This routine is also guaranteed to have worst case constant space
     /// complexity.
     ///
     /// # Examples
     ///
     /// Basic usage:
     ///
     /// ```
     /// use memchr::memmem::Finder;
     ///
     /// let haystack = b&quot;foo bar foo baz foo&quot;;
     /// let finder = Finder::new(b&quot;foo&quot;);
     /// let mut it = finder.find_iter(haystack);
     /// assert_eq!(Some(0), it.next());
     /// assert_eq!(Some(8), it.next());
     /// assert_eq!(Some(16), it.next());
     /// assert_eq!(None, it.next());
     /// ```
     </span><span class="attribute">#[inline]
     </span><span class="kw">pub fn </span>find_iter&lt;<span class="lifetime">&#39;a</span>, <span class="lifetime">&#39;h</span>&gt;(
         <span class="kw-2">&amp;</span><span class="lifetime">&#39;a </span><span class="self">self</span>,
         haystack: <span class="kw-2">&amp;</span><span class="lifetime">&#39;h </span>[u8],
     ) -&gt; FindIter&lt;<span class="lifetime">&#39;h</span>, <span class="lifetime">&#39;a</span>&gt; {
         FindIter::new(haystack, <span class="self">self</span>.as_ref())
     }

     <span class="doccomment">/// Convert this finder into its owned variant, such that it no longer
     /// borrows the needle.
     ///
     /// If this is already an owned finder, then this is a no-op. Otherwise,
     /// this copies the needle.
     ///
     /// This is only available when the `std` feature is enabled.
     </span><span class="attribute">#[cfg(feature = <span class="string">&quot;std&quot;</span>)]
     #[inline]
     </span><span class="kw">pub fn </span>into_owned(<span class="self">self</span>) -&gt; Finder&lt;<span class="lifetime">&#39;static</span>&gt; {
         Finder { searcher: <span class="self">self</span>.searcher.into_owned() }
     }

     <span class="doccomment">/// Convert this finder into its borrowed variant.
     ///
     /// This is primarily useful if your finder is owned and you&#39;d like to
     /// store its borrowed variant in some intermediate data structure.
     ///
     /// Note that the lifetime parameter of the returned finder is tied to the
     /// lifetime of `self`, and may be shorter than the `&#39;n` lifetime of the
     /// needle itself. Namely, a finder&#39;s needle can be either borrowed or
     /// owned, so the lifetime of the needle returned must necessarily be the
     /// shorter of the two.
     </span><span class="attribute">#[inline]
     </span><span class="kw">pub fn </span>as_ref(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; Finder&lt;<span class="lifetime">&#39;_</span>&gt; {
         Finder { searcher: <span class="self">self</span>.searcher.as_ref() }
     }

     <span class="doccomment">/// Returns the needle that this finder searches for.
     ///
     /// Note that the lifetime of the needle returned is tied to the lifetime
     /// of the finder, and may be shorter than the `&#39;n` lifetime. Namely, a
     /// finder&#39;s needle can be either borrowed or owned, so the lifetime of the
     /// needle returned must necessarily be the shorter of the two.
     </span><span class="attribute">#[inline]
     </span><span class="kw">pub fn </span>needle(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="kw-2">&amp;</span>[u8] {
         <span class="self">self</span>.searcher.needle()
     }
 }

 <span class="doccomment">/// A single substring reverse searcher fixed to a particular needle.
 ///
 /// The purpose of this type is to permit callers to construct a substring
 /// searcher that can be used to search haystacks without the overhead of
 /// constructing the searcher in the first place. This is a somewhat niche
 /// concern when it&#39;s necessary to re-use the same needle to search multiple
 /// different haystacks with as little overhead as possible. In general,
 /// using [`rfind`] is good enough, but `FinderRev` is useful when you can
 /// meaningfully observe searcher construction time in a profile.
 ///
 /// When the `std` feature is enabled, then this type has an `into_owned`
 /// version which permits building a `FinderRev` that is not connected to
 /// the lifetime of its needle.
 </span><span class="attribute">#[derive(Clone, Debug)]
 </span><span class="kw">pub struct </span>FinderRev&lt;<span class="lifetime">&#39;n</span>&gt; {
     searcher: SearcherRev&lt;<span class="lifetime">&#39;n</span>&gt;,
 }

 <span class="kw">impl</span>&lt;<span class="lifetime">&#39;n</span>&gt; FinderRev&lt;<span class="lifetime">&#39;n</span>&gt; {
     <span class="doccomment">/// Create a new reverse finder for the given needle.
     </span><span class="attribute">#[inline]
     </span><span class="kw">pub fn </span>new&lt;B: <span class="question-mark">?</span>Sized + AsRef&lt;[u8]&gt;&gt;(needle: <span class="kw-2">&amp;</span><span class="lifetime">&#39;n </span>B) -&gt; FinderRev&lt;<span class="lifetime">&#39;n</span>&gt; {
         FinderBuilder::new().build_reverse(needle)
     }

     <span class="doccomment">/// Returns the index of the last occurrence of this needle in the given
     /// haystack.
     ///
     /// The haystack may be any type that can be cheaply converted into a
     /// `&amp;[u8]`. This includes, but is not limited to, `&amp;str` and `&amp;[u8]`.
     ///
     /// # Complexity
     ///
     /// This routine is guaranteed to have worst case linear time complexity
     /// with respect to both the needle and the haystack. That is, this runs
     /// in `O(needle.len() + haystack.len())` time.
     ///
     /// This routine is also guaranteed to have worst case constant space
     /// complexity.
     ///
     /// # Examples
     ///
     /// Basic usage:
     ///
     /// ```
     /// use memchr::memmem::FinderRev;
     ///
     /// let haystack = b&quot;foo bar baz&quot;;
     /// assert_eq!(Some(0), FinderRev::new(&quot;foo&quot;).rfind(haystack));
     /// assert_eq!(Some(4), FinderRev::new(&quot;bar&quot;).rfind(haystack));
     /// assert_eq!(None, FinderRev::new(&quot;quux&quot;).rfind(haystack));
     /// ```
     </span><span class="kw">pub fn </span>rfind&lt;B: AsRef&lt;[u8]&gt;&gt;(<span class="kw-2">&amp;</span><span class="self">self</span>, haystack: B) -&gt; <span class="prelude-ty">Option</span>&lt;usize&gt; {
         <span class="self">self</span>.searcher.rfind(haystack.as_ref())
     }

     <span class="doccomment">/// Returns a reverse iterator over all occurrences of a substring in a
     /// haystack.
     ///
     /// # Complexity
     ///
     /// This routine is guaranteed to have worst case linear time complexity
     /// with respect to both the needle and the haystack. That is, this runs
     /// in `O(needle.len() + haystack.len())` time.
     ///
     /// This routine is also guaranteed to have worst case constant space
     /// complexity.
     ///
     /// # Examples
     ///
     /// Basic usage:
     ///
     /// ```
     /// use memchr::memmem::FinderRev;
     ///
     /// let haystack = b&quot;foo bar foo baz foo&quot;;
     /// let finder = FinderRev::new(b&quot;foo&quot;);
     /// let mut it = finder.rfind_iter(haystack);
     /// assert_eq!(Some(16), it.next());
     /// assert_eq!(Some(8), it.next());
     /// assert_eq!(Some(0), it.next());
     /// assert_eq!(None, it.next());
     /// ```
     </span><span class="attribute">#[inline]
     </span><span class="kw">pub fn </span>rfind_iter&lt;<span class="lifetime">&#39;a</span>, <span class="lifetime">&#39;h</span>&gt;(
         <span class="kw-2">&amp;</span><span class="lifetime">&#39;a </span><span class="self">self</span>,
         haystack: <span class="kw-2">&amp;</span><span class="lifetime">&#39;h </span>[u8],
     ) -&gt; FindRevIter&lt;<span class="lifetime">&#39;h</span>, <span class="lifetime">&#39;a</span>&gt; {
         FindRevIter::new(haystack, <span class="self">self</span>.as_ref())
     }

     <span class="doccomment">/// Convert this finder into its owned variant, such that it no longer
     /// borrows the needle.
     ///
     /// If this is already an owned finder, then this is a no-op. Otherwise,
     /// this copies the needle.
     ///
     /// This is only available when the `std` feature is enabled.
     </span><span class="attribute">#[cfg(feature = <span class="string">&quot;std&quot;</span>)]
     #[inline]
     </span><span class="kw">pub fn </span>into_owned(<span class="self">self</span>) -&gt; FinderRev&lt;<span class="lifetime">&#39;static</span>&gt; {
         FinderRev { searcher: <span class="self">self</span>.searcher.into_owned() }
     }

     <span class="doccomment">/// Convert this finder into its borrowed variant.
     ///
     /// This is primarily useful if your finder is owned and you&#39;d like to
     /// store its borrowed variant in some intermediate data structure.
     ///
     /// Note that the lifetime parameter of the returned finder is tied to the
     /// lifetime of `self`, and may be shorter than the `&#39;n` lifetime of the
     /// needle itself. Namely, a finder&#39;s needle can be either borrowed or
     /// owned, so the lifetime of the needle returned must necessarily be the
     /// shorter of the two.
     </span><span class="attribute">#[inline]
     </span><span class="kw">pub fn </span>as_ref(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; FinderRev&lt;<span class="lifetime">&#39;_</span>&gt; {
         FinderRev { searcher: <span class="self">self</span>.searcher.as_ref() }
     }

     <span class="doccomment">/// Returns the needle that this finder searches for.
     ///
     /// Note that the lifetime of the needle returned is tied to the lifetime
     /// of the finder, and may be shorter than the `&#39;n` lifetime. Namely, a
     /// finder&#39;s needle can be either borrowed or owned, so the lifetime of the
     /// needle returned must necessarily be the shorter of the two.
     </span><span class="attribute">#[inline]
     </span><span class="kw">pub fn </span>needle(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="kw-2">&amp;</span>[u8] {
         <span class="self">self</span>.searcher.needle()
     }
 }

 <span class="doccomment">/// A builder for constructing non-default forward or reverse memmem finders.
 ///
 /// A builder is primarily useful for configuring a substring searcher.
 /// Currently, the only configuration exposed is the ability to disable
 /// heuristic prefilters used to speed up certain searches.
 </span><span class="attribute">#[derive(Clone, Debug, Default)]
 </span><span class="kw">pub struct </span>FinderBuilder {
     config: SearcherConfig,
 }

 <span class="kw">impl </span>FinderBuilder {
     <span class="doccomment">/// Create a new finder builder with default settings.
     </span><span class="kw">pub fn </span>new() -&gt; FinderBuilder {
         FinderBuilder::default()
     }

     <span class="doccomment">/// Build a forward finder using the given needle from the current
     /// settings.
     </span><span class="kw">pub fn </span>build_forward&lt;<span class="lifetime">&#39;n</span>, B: <span class="question-mark">?</span>Sized + AsRef&lt;[u8]&gt;&gt;(
         <span class="kw-2">&amp;</span><span class="self">self</span>,
         needle: <span class="kw-2">&amp;</span><span class="lifetime">&#39;n </span>B,
     ) -&gt; Finder&lt;<span class="lifetime">&#39;n</span>&gt; {
         Finder { searcher: Searcher::new(<span class="self">self</span>.config, needle.as_ref()) }
     }

     <span class="doccomment">/// Build a reverse finder using the given needle from the current
     /// settings.
     </span><span class="kw">pub fn </span>build_reverse&lt;<span class="lifetime">&#39;n</span>, B: <span class="question-mark">?</span>Sized + AsRef&lt;[u8]&gt;&gt;(
         <span class="kw-2">&amp;</span><span class="self">self</span>,
         needle: <span class="kw-2">&amp;</span><span class="lifetime">&#39;n </span>B,
     ) -&gt; FinderRev&lt;<span class="lifetime">&#39;n</span>&gt; {
         FinderRev { searcher: SearcherRev::new(needle.as_ref()) }
     }

     <span class="doccomment">/// Configure the prefilter setting for the finder.
     ///
     /// See the documentation for [`Prefilter`] for more discussion on why
     /// you might want to configure this.
     </span><span class="kw">pub fn </span>prefilter(<span class="kw-2">&amp;mut </span><span class="self">self</span>, prefilter: Prefilter) -&gt; <span class="kw-2">&amp;mut </span>FinderBuilder {
         <span class="self">self</span>.config.prefilter = prefilter;
         <span class="self">self
     </span>}
 }

 <span class="doccomment">/// The internal implementation of a forward substring searcher.
 ///
 /// The reality is that this is a &quot;meta&quot; searcher. Namely, depending on a
 /// variety of parameters (CPU support, target, needle size, haystack size and
 /// even dynamic properties such as prefilter effectiveness), the actual
 /// algorithm employed to do substring search may change.
 </span><span class="attribute">#[derive(Clone, Debug)]
 </span><span class="kw">struct </span>Searcher&lt;<span class="lifetime">&#39;n</span>&gt; {
     <span class="doccomment">/// The actual needle we&#39;re searching for.
     ///
     /// A CowBytes is like a Cow&lt;[u8]&gt;, except in no_std environments, it is
     /// specialized to a single variant (the borrowed form).
     </span>needle: CowBytes&lt;<span class="lifetime">&#39;n</span>&gt;,
     <span class="doccomment">/// A collection of facts computed on the needle that are useful for more
     /// than one substring search algorithm.
     </span>ninfo: NeedleInfo,
     <span class="doccomment">/// A prefilter function, if it was deemed appropriate.
     ///
     /// Some substring search implementations (like Two-Way) benefit greatly
     /// if we can quickly find candidate starting positions for a match.
     </span>prefn: <span class="prelude-ty">Option</span>&lt;PrefilterFn&gt;,
     <span class="doccomment">/// The actual substring implementation in use.
     </span>kind: SearcherKind,
 }

 <span class="doccomment">/// A collection of facts computed about a search needle.
 ///
 /// We group these things together because it&#39;s useful to be able to hand them
 /// to prefilters or substring algorithms that want them.
 </span><span class="attribute">#[derive(Clone, Copy, Debug)]
 </span><span class="kw">pub</span>(<span class="kw">crate</span>) <span class="kw">struct </span>NeedleInfo {
     <span class="doccomment">/// The offsets of &quot;rare&quot; bytes detected in the needle.
     ///
     /// This is meant to be a heuristic in order to maximize the effectiveness
     /// of vectorized code. Namely, vectorized code tends to focus on only
     /// one or two bytes. If we pick bytes from the needle that occur
     /// infrequently, then more time will be spent in the vectorized code and
     /// will likely make the overall search (much) faster.
     ///
     /// Of course, this is only a heuristic based on a background frequency
     /// distribution of bytes. But it tends to work very well in practice.
     </span><span class="kw">pub</span>(<span class="kw">crate</span>) rarebytes: RareNeedleBytes,
     <span class="doccomment">/// A Rabin-Karp hash of the needle.
     ///
     /// This is store here instead of in a more specific Rabin-Karp search
     /// since Rabin-Karp may be used even if another SearchKind corresponds
     /// to some other search implementation. e.g., If measurements suggest RK
     /// is faster in some cases or if a search implementation can&#39;t handle
     /// particularly small haystack. (Moreover, we cannot use RK *generally*,
     /// since its worst case time is multiplicative. Instead, we only use it
     /// some small haystacks, where &quot;small&quot; is a constant.)
     </span><span class="kw">pub</span>(<span class="kw">crate</span>) nhash: NeedleHash,
 }

 <span class="doccomment">/// Configuration for substring search.
 </span><span class="attribute">#[derive(Clone, Copy, Debug, Default)]
 </span><span class="kw">struct </span>SearcherConfig {
     <span class="doccomment">/// This permits changing the behavior of the prefilter, since it can have
     /// a variable impact on performance.
     </span>prefilter: Prefilter,
 }

 <span class="attribute">#[derive(Clone, Debug)]
 </span><span class="kw">enum </span>SearcherKind {
     <span class="doccomment">/// A special case for empty needles. An empty needle always matches, even
     /// in an empty haystack.
     </span>Empty,
     <span class="doccomment">/// This is used whenever the needle is a single byte. In this case, we
     /// always use memchr.
     </span>OneByte(u8),
     <span class="doccomment">/// Two-Way is the generic work horse and is what provides our additive
     /// linear time guarantee. In general, it&#39;s used when the needle is bigger
     /// than 8 bytes or so.
     </span>TwoWay(twoway::Forward),
     <span class="attribute">#[cfg(all(not(miri), target_arch = <span class="string">&quot;x86_64&quot;</span>, memchr_runtime_simd))]
     </span>GenericSIMD128(x86::sse::Forward),
     <span class="attribute">#[cfg(memchr_runtime_wasm128)]
     </span>GenericSIMD128(wasm::Forward),
     <span class="attribute">#[cfg(all(not(miri), target_arch = <span class="string">&quot;x86_64&quot;</span>, memchr_runtime_simd))]
     </span>GenericSIMD256(x86::avx::Forward),
 }

 <span class="kw">impl</span>&lt;<span class="lifetime">&#39;n</span>&gt; Searcher&lt;<span class="lifetime">&#39;n</span>&gt; {
     <span class="kw">fn </span>new(config: SearcherConfig, needle: <span class="kw-2">&amp;</span><span class="lifetime">&#39;n </span>[u8]) -&gt; Searcher&lt;<span class="lifetime">&#39;n</span>&gt; {
         <span class="kw">use </span><span class="self">self</span>::SearcherKind::<span class="kw-2">*</span>;

         <span class="kw">let </span>ninfo = NeedleInfo::new(needle);
         <span class="kw">let </span>mk = |kind: SearcherKind| {
             <span class="kw">let </span>prefn = prefilter::forward(
                 <span class="kw-2">&amp;</span>config.prefilter,
                 <span class="kw-2">&amp;</span>ninfo.rarebytes,
                 needle,
             );
             Searcher { needle: CowBytes::new(needle), ninfo, prefn, kind }
         };
         <span class="kw">if </span>needle.len() == <span class="number">0 </span>{
             <span class="kw">return </span>mk(Empty);
         }
         <span class="kw">if </span>needle.len() == <span class="number">1 </span>{
             <span class="kw">return </span>mk(OneByte(needle[<span class="number">0</span>]));
         }
         <span class="attribute">#[cfg(all(not(miri), target_arch = <span class="string">&quot;x86_64&quot;</span>, memchr_runtime_simd))]
         </span>{
             <span class="kw">if let </span><span class="prelude-val">Some</span>(fwd) = x86::avx::Forward::new(<span class="kw-2">&amp;</span>ninfo, needle) {
                 <span class="kw">return </span>mk(GenericSIMD256(fwd));
             } <span class="kw">else if let </span><span class="prelude-val">Some</span>(fwd) = x86::sse::Forward::new(<span class="kw-2">&amp;</span>ninfo, needle) {
                 <span class="kw">return </span>mk(GenericSIMD128(fwd));
             }
         }
         <span class="attribute">#[cfg(all(target_arch = <span class="string">&quot;wasm32&quot;</span>, memchr_runtime_simd))]
         </span>{
             <span class="kw">if let </span><span class="prelude-val">Some</span>(fwd) = wasm::Forward::new(<span class="kw-2">&amp;</span>ninfo, needle) {
                 <span class="kw">return </span>mk(GenericSIMD128(fwd));
             }
         }

         mk(TwoWay(twoway::Forward::new(needle)))
     }

     <span class="doccomment">/// Return a fresh prefilter state that can be used with this searcher.
     /// A prefilter state is used to track the effectiveness of a searcher&#39;s
     /// prefilter for speeding up searches. Therefore, the prefilter state
     /// should generally be reused on subsequent searches (such as in an
     /// iterator). For searches on a different haystack, then a new prefilter
     /// state should be used.
     ///
     /// This always initializes a valid (but possibly inert) prefilter state
     /// even if this searcher does not have a prefilter enabled.
     </span><span class="kw">fn </span>prefilter_state(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; PrefilterState {
         <span class="kw">if </span><span class="self">self</span>.prefn.is_none() {
             PrefilterState::inert()
         } <span class="kw">else </span>{
             PrefilterState::new()
         }
     }

     <span class="kw">fn </span>needle(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="kw-2">&amp;</span>[u8] {
         <span class="self">self</span>.needle.as_slice()
     }

     <span class="kw">fn </span>as_ref(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; Searcher&lt;<span class="lifetime">&#39;_</span>&gt; {
         <span class="kw">use </span><span class="self">self</span>::SearcherKind::<span class="kw-2">*</span>;

         <span class="kw">let </span>kind = <span class="kw">match </span><span class="self">self</span>.kind {
             Empty =&gt; Empty,
             OneByte(b) =&gt; OneByte(b),
             TwoWay(tw) =&gt; TwoWay(tw),
             <span class="attribute">#[cfg(all(not(miri), memchr_runtime_simd))]
             </span>GenericSIMD128(gs) =&gt; GenericSIMD128(gs),
             <span class="attribute">#[cfg(all(
                 not(miri),
                 target_arch = <span class="string">&quot;x86_64&quot;</span>,
                 memchr_runtime_simd
             ))]
             </span>GenericSIMD256(gs) =&gt; GenericSIMD256(gs),
         };
         Searcher {
             needle: CowBytes::new(<span class="self">self</span>.needle()),
             ninfo: <span class="self">self</span>.ninfo,
             prefn: <span class="self">self</span>.prefn,
             kind,
         }
     }

     <span class="attribute">#[cfg(feature = <span class="string">&quot;std&quot;</span>)]
     </span><span class="kw">fn </span>into_owned(<span class="self">self</span>) -&gt; Searcher&lt;<span class="lifetime">&#39;static</span>&gt; {
         <span class="kw">use </span><span class="self">self</span>::SearcherKind::<span class="kw-2">*</span>;

         <span class="kw">let </span>kind = <span class="kw">match </span><span class="self">self</span>.kind {
             Empty =&gt; Empty,
             OneByte(b) =&gt; OneByte(b),
             TwoWay(tw) =&gt; TwoWay(tw),
             <span class="attribute">#[cfg(all(not(miri), memchr_runtime_simd))]
             </span>GenericSIMD128(gs) =&gt; GenericSIMD128(gs),
             <span class="attribute">#[cfg(all(
                 not(miri),
                 target_arch = <span class="string">&quot;x86_64&quot;</span>,
                 memchr_runtime_simd
             ))]
             </span>GenericSIMD256(gs) =&gt; GenericSIMD256(gs),
         };
         Searcher {
             needle: <span class="self">self</span>.needle.into_owned(),
             ninfo: <span class="self">self</span>.ninfo,
             prefn: <span class="self">self</span>.prefn,
             kind,
         }
     }

     <span class="doccomment">/// Implements forward substring search by selecting the implementation
     /// chosen at construction and executing it on the given haystack with the
     /// prefilter&#39;s current state of effectiveness.
     </span><span class="attribute">#[inline(always)]
     </span><span class="kw">fn </span>find(
         <span class="kw-2">&amp;</span><span class="self">self</span>,
         state: <span class="kw-2">&amp;mut </span>PrefilterState,
         haystack: <span class="kw-2">&amp;</span>[u8],
     ) -&gt; <span class="prelude-ty">Option</span>&lt;usize&gt; {
         <span class="kw">use </span><span class="self">self</span>::SearcherKind::<span class="kw-2">*</span>;

         <span class="kw">let </span>needle = <span class="self">self</span>.needle();
         <span class="kw">if </span>haystack.len() &lt; needle.len() {
             <span class="kw">return </span><span class="prelude-val">None</span>;
         }
         <span class="kw">match </span><span class="self">self</span>.kind {
             Empty =&gt; <span class="prelude-val">Some</span>(<span class="number">0</span>),
             OneByte(b) =&gt; <span class="kw">crate</span>::memchr(b, haystack),
             TwoWay(<span class="kw-2">ref </span>tw) =&gt; {
                 <span class="comment">// For very short haystacks (e.g., where the prefilter probably
                 // can&#39;t run), it&#39;s faster to just run RK.
                 </span><span class="kw">if </span>rabinkarp::is_fast(haystack, needle) {
                     rabinkarp::find_with(<span class="kw-2">&amp;</span><span class="self">self</span>.ninfo.nhash, haystack, needle)
                 } <span class="kw">else </span>{
                     <span class="self">self</span>.find_tw(tw, state, haystack, needle)
                 }
             }
             <span class="attribute">#[cfg(all(not(miri), memchr_runtime_simd))]
             </span>GenericSIMD128(<span class="kw-2">ref </span>gs) =&gt; {
                 <span class="comment">// The SIMD matcher can&#39;t handle particularly short haystacks,
                 // so we fall back to RK in these cases.
                 </span><span class="kw">if </span>haystack.len() &lt; gs.min_haystack_len() {
                     rabinkarp::find_with(<span class="kw-2">&amp;</span><span class="self">self</span>.ninfo.nhash, haystack, needle)
                 } <span class="kw">else </span>{
                     gs.find(haystack, needle)
                 }
             }
             <span class="attribute">#[cfg(all(
                 not(miri),
                 target_arch = <span class="string">&quot;x86_64&quot;</span>,
                 memchr_runtime_simd
             ))]
             </span>GenericSIMD256(<span class="kw-2">ref </span>gs) =&gt; {
                 <span class="comment">// The SIMD matcher can&#39;t handle particularly short haystacks,
                 // so we fall back to RK in these cases.
                 </span><span class="kw">if </span>haystack.len() &lt; gs.min_haystack_len() {
                     rabinkarp::find_with(<span class="kw-2">&amp;</span><span class="self">self</span>.ninfo.nhash, haystack, needle)
                 } <span class="kw">else </span>{
                     gs.find(haystack, needle)
                 }
             }
         }
     }

     <span class="doccomment">/// Calls Two-Way on the given haystack/needle.
     ///
     /// This is marked as unlineable since it seems to have a better overall
     /// effect on benchmarks. However, this is one of those cases where
     /// inlining it results an improvement in other benchmarks too, so I
     /// suspect we just don&#39;t have enough data yet to make the right call here.
     ///
     /// I suspect the main problem is that this function contains two different
     /// inlined copies of Two-Way: one with and one without prefilters enabled.
     </span><span class="attribute">#[inline(never)]
     </span><span class="kw">fn </span>find_tw(
         <span class="kw-2">&amp;</span><span class="self">self</span>,
         tw: <span class="kw-2">&amp;</span>twoway::Forward,
         state: <span class="kw-2">&amp;mut </span>PrefilterState,
         haystack: <span class="kw-2">&amp;</span>[u8],
         needle: <span class="kw-2">&amp;</span>[u8],
     ) -&gt; <span class="prelude-ty">Option</span>&lt;usize&gt; {
         <span class="kw">if let </span><span class="prelude-val">Some</span>(prefn) = <span class="self">self</span>.prefn {
             <span class="comment">// We used to look at the length of a haystack here. That is, if
             // it was too small, then don&#39;t bother with the prefilter. But two
             // things changed: the prefilter falls back to memchr for small
             // haystacks, and, above, Rabin-Karp is employed for tiny haystacks
             // anyway.
             </span><span class="kw">if </span>state.is_effective() {
                 <span class="kw">let </span><span class="kw-2">mut </span>pre = Pre { state, prefn, ninfo: <span class="kw-2">&amp;</span><span class="self">self</span>.ninfo };
                 <span class="kw">return </span>tw.find(<span class="prelude-val">Some</span>(<span class="kw-2">&amp;mut </span>pre), haystack, needle);
             }
         }
         tw.find(<span class="prelude-val">None</span>, haystack, needle)
     }
 }

 <span class="kw">impl </span>NeedleInfo {
     <span class="kw">pub</span>(<span class="kw">crate</span>) <span class="kw">fn </span>new(needle: <span class="kw-2">&amp;</span>[u8]) -&gt; NeedleInfo {
         NeedleInfo {
             rarebytes: RareNeedleBytes::forward(needle),
             nhash: NeedleHash::forward(needle),
         }
     }
 }

 <span class="doccomment">/// The internal implementation of a reverse substring searcher.
 ///
 /// See the forward searcher docs for more details. Currently, the reverse
 /// searcher is considerably simpler since it lacks prefilter support. This
 /// was done because it adds a lot of code, and more surface area to test. And
 /// in particular, it&#39;s not clear whether a prefilter on reverse searching is
 /// worth it. (If you have a compelling use case, please file an issue!)
 </span><span class="attribute">#[derive(Clone, Debug)]
 </span><span class="kw">struct </span>SearcherRev&lt;<span class="lifetime">&#39;n</span>&gt; {
     <span class="doccomment">/// The actual needle we&#39;re searching for.
     </span>needle: CowBytes&lt;<span class="lifetime">&#39;n</span>&gt;,
     <span class="doccomment">/// A Rabin-Karp hash of the needle.
     </span>nhash: NeedleHash,
     <span class="doccomment">/// The actual substring implementation in use.
     </span>kind: SearcherRevKind,
 }

 <span class="attribute">#[derive(Clone, Debug)]
 </span><span class="kw">enum </span>SearcherRevKind {
     <span class="doccomment">/// A special case for empty needles. An empty needle always matches, even
     /// in an empty haystack.
     </span>Empty,
     <span class="doccomment">/// This is used whenever the needle is a single byte. In this case, we
     /// always use memchr.
     </span>OneByte(u8),
     <span class="doccomment">/// Two-Way is the generic work horse and is what provides our additive
     /// linear time guarantee. In general, it&#39;s used when the needle is bigger
     /// than 8 bytes or so.
     </span>TwoWay(twoway::Reverse),
 }

 <span class="kw">impl</span>&lt;<span class="lifetime">&#39;n</span>&gt; SearcherRev&lt;<span class="lifetime">&#39;n</span>&gt; {
     <span class="kw">fn </span>new(needle: <span class="kw-2">&amp;</span><span class="lifetime">&#39;n </span>[u8]) -&gt; SearcherRev&lt;<span class="lifetime">&#39;n</span>&gt; {
         <span class="kw">use </span><span class="self">self</span>::SearcherRevKind::<span class="kw-2">*</span>;

         <span class="kw">let </span>kind = <span class="kw">if </span>needle.len() == <span class="number">0 </span>{
             Empty
         } <span class="kw">else if </span>needle.len() == <span class="number">1 </span>{
             OneByte(needle[<span class="number">0</span>])
         } <span class="kw">else </span>{
             TwoWay(twoway::Reverse::new(needle))
         };
         SearcherRev {
             needle: CowBytes::new(needle),
             nhash: NeedleHash::reverse(needle),
             kind,
         }
     }

     <span class="kw">fn </span>needle(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="kw-2">&amp;</span>[u8] {
         <span class="self">self</span>.needle.as_slice()
     }

     <span class="kw">fn </span>as_ref(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; SearcherRev&lt;<span class="lifetime">&#39;_</span>&gt; {
         <span class="kw">use </span><span class="self">self</span>::SearcherRevKind::<span class="kw-2">*</span>;

         <span class="kw">let </span>kind = <span class="kw">match </span><span class="self">self</span>.kind {
             Empty =&gt; Empty,
             OneByte(b) =&gt; OneByte(b),
             TwoWay(tw) =&gt; TwoWay(tw),
         };
         SearcherRev {
             needle: CowBytes::new(<span class="self">self</span>.needle()),
             nhash: <span class="self">self</span>.nhash,
             kind,
         }
     }

     <span class="attribute">#[cfg(feature = <span class="string">&quot;std&quot;</span>)]
     </span><span class="kw">fn </span>into_owned(<span class="self">self</span>) -&gt; SearcherRev&lt;<span class="lifetime">&#39;static</span>&gt; {
         <span class="kw">use </span><span class="self">self</span>::SearcherRevKind::<span class="kw-2">*</span>;

         <span class="kw">let </span>kind = <span class="kw">match </span><span class="self">self</span>.kind {
             Empty =&gt; Empty,
             OneByte(b) =&gt; OneByte(b),
             TwoWay(tw) =&gt; TwoWay(tw),
         };
         SearcherRev {
             needle: <span class="self">self</span>.needle.into_owned(),
             nhash: <span class="self">self</span>.nhash,
             kind,
         }
     }

     <span class="doccomment">/// Implements reverse substring search by selecting the implementation
     /// chosen at construction and executing it on the given haystack with the
     /// prefilter&#39;s current state of effectiveness.
     </span><span class="attribute">#[inline(always)]
     </span><span class="kw">fn </span>rfind(<span class="kw-2">&amp;</span><span class="self">self</span>, haystack: <span class="kw-2">&amp;</span>[u8]) -&gt; <span class="prelude-ty">Option</span>&lt;usize&gt; {
         <span class="kw">use </span><span class="self">self</span>::SearcherRevKind::<span class="kw-2">*</span>;

         <span class="kw">let </span>needle = <span class="self">self</span>.needle();
         <span class="kw">if </span>haystack.len() &lt; needle.len() {
             <span class="kw">return </span><span class="prelude-val">None</span>;
         }
         <span class="kw">match </span><span class="self">self</span>.kind {
             Empty =&gt; <span class="prelude-val">Some</span>(haystack.len()),
             OneByte(b) =&gt; <span class="kw">crate</span>::memrchr(b, haystack),
             TwoWay(<span class="kw-2">ref </span>tw) =&gt; {
                 <span class="comment">// For very short haystacks (e.g., where the prefilter probably
                 // can&#39;t run), it&#39;s faster to just run RK.
                 </span><span class="kw">if </span>rabinkarp::is_fast(haystack, needle) {
                     rabinkarp::rfind_with(<span class="kw-2">&amp;</span><span class="self">self</span>.nhash, haystack, needle)
                 } <span class="kw">else </span>{
                     tw.rfind(haystack, needle)
                 }
             }
         }
     }
 }

 <span class="doccomment">/// This module defines some generic quickcheck properties useful for testing
 /// any substring search algorithm. It also runs those properties for the
 /// top-level public API memmem routines. (The properties are also used to
 /// test various substring search implementations more granularly elsewhere as
 /// well.)
 </span><span class="attribute">#[cfg(all(test, feature = <span class="string">&quot;std&quot;</span>, not(miri)))]
 </span><span class="kw">mod </span>proptests {
     <span class="comment">// N.B. This defines the quickcheck tests using the properties defined
     // below. Because of macro-visibility weirdness, the actual macro is
     // defined at the top of this file.
     </span><span class="macro">define_memmem_quickcheck_tests!</span>(<span class="kw">super</span>::find, <span class="kw">super</span>::rfind);

     <span class="doccomment">/// Check that every prefix of the given byte string is a substring.
     </span><span class="kw">pub</span>(<span class="kw">crate</span>) <span class="kw">fn </span>prefix_is_substring(
         reverse: bool,
         bs: <span class="kw-2">&amp;</span>[u8],
         <span class="kw-2">mut </span>search: <span class="kw">impl </span>FnMut(<span class="kw-2">&amp;</span>[u8], <span class="kw-2">&amp;</span>[u8]) -&gt; <span class="prelude-ty">Option</span>&lt;usize&gt;,
     ) -&gt; bool {
         <span class="kw">if </span>bs.is_empty() {
             <span class="kw">return </span><span class="bool-val">true</span>;
         }
         <span class="kw">for </span>i <span class="kw">in </span><span class="number">0</span>..(bs.len() - <span class="number">1</span>) {
             <span class="kw">let </span>prefix = <span class="kw-2">&amp;</span>bs[..i];
             <span class="kw">if </span>reverse {
                 <span class="macro">assert_eq!</span>(naive_rfind(bs, prefix), search(bs, prefix));
             } <span class="kw">else </span>{
                 <span class="macro">assert_eq!</span>(naive_find(bs, prefix), search(bs, prefix));
             }
         }
         <span class="bool-val">true
     </span>}

     <span class="doccomment">/// Check that every suffix of the given byte string is a substring.
     </span><span class="kw">pub</span>(<span class="kw">crate</span>) <span class="kw">fn </span>suffix_is_substring(
         reverse: bool,
         bs: <span class="kw-2">&amp;</span>[u8],
         <span class="kw-2">mut </span>search: <span class="kw">impl </span>FnMut(<span class="kw-2">&amp;</span>[u8], <span class="kw-2">&amp;</span>[u8]) -&gt; <span class="prelude-ty">Option</span>&lt;usize&gt;,
     ) -&gt; bool {
         <span class="kw">if </span>bs.is_empty() {
             <span class="kw">return </span><span class="bool-val">true</span>;
         }
         <span class="kw">for </span>i <span class="kw">in </span><span class="number">0</span>..(bs.len() - <span class="number">1</span>) {
             <span class="kw">let </span>suffix = <span class="kw-2">&amp;</span>bs[i..];
             <span class="kw">if </span>reverse {
                 <span class="macro">assert_eq!</span>(naive_rfind(bs, suffix), search(bs, suffix));
             } <span class="kw">else </span>{
                 <span class="macro">assert_eq!</span>(naive_find(bs, suffix), search(bs, suffix));
             }
         }
         <span class="bool-val">true
     </span>}

     <span class="doccomment">/// Check that naive substring search matches the result of the given search
     /// algorithm.
     </span><span class="kw">pub</span>(<span class="kw">crate</span>) <span class="kw">fn </span>matches_naive(
         reverse: bool,
         haystack: <span class="kw-2">&amp;</span>[u8],
         needle: <span class="kw-2">&amp;</span>[u8],
         <span class="kw-2">mut </span>search: <span class="kw">impl </span>FnMut(<span class="kw-2">&amp;</span>[u8], <span class="kw-2">&amp;</span>[u8]) -&gt; <span class="prelude-ty">Option</span>&lt;usize&gt;,
     ) -&gt; bool {
         <span class="kw">if </span>reverse {
             naive_rfind(haystack, needle) == search(haystack, needle)
         } <span class="kw">else </span>{
             naive_find(haystack, needle) == search(haystack, needle)
         }
     }

     <span class="doccomment">/// Naively search forwards for the given needle in the given haystack.
     </span><span class="kw">fn </span>naive_find(haystack: <span class="kw-2">&amp;</span>[u8], needle: <span class="kw-2">&amp;</span>[u8]) -&gt; <span class="prelude-ty">Option</span>&lt;usize&gt; {
         <span class="kw">if </span>needle.is_empty() {
             <span class="kw">return </span><span class="prelude-val">Some</span>(<span class="number">0</span>);
         } <span class="kw">else if </span>haystack.len() &lt; needle.len() {
             <span class="kw">return </span><span class="prelude-val">None</span>;
         }
         <span class="kw">for </span>i <span class="kw">in </span><span class="number">0</span>..(haystack.len() - needle.len() + <span class="number">1</span>) {
             <span class="kw">if </span>needle == <span class="kw-2">&amp;</span>haystack[i..i + needle.len()] {
                 <span class="kw">return </span><span class="prelude-val">Some</span>(i);
             }
         }
         <span class="prelude-val">None
     </span>}

     <span class="doccomment">/// Naively search in reverse for the given needle in the given haystack.
     </span><span class="kw">fn </span>naive_rfind(haystack: <span class="kw-2">&amp;</span>[u8], needle: <span class="kw-2">&amp;</span>[u8]) -&gt; <span class="prelude-ty">Option</span>&lt;usize&gt; {
         <span class="kw">if </span>needle.is_empty() {
             <span class="kw">return </span><span class="prelude-val">Some</span>(haystack.len());
         } <span class="kw">else if </span>haystack.len() &lt; needle.len() {
             <span class="kw">return </span><span class="prelude-val">None</span>;
         }
         <span class="kw">for </span>i <span class="kw">in </span>(<span class="number">0</span>..(haystack.len() - needle.len() + <span class="number">1</span>)).rev() {
             <span class="kw">if </span>needle == <span class="kw-2">&amp;</span>haystack[i..i + needle.len()] {
                 <span class="kw">return </span><span class="prelude-val">Some</span>(i);
             }
         }
         <span class="prelude-val">None
     </span>}
 }

 <span class="doccomment">/// This module defines some hand-written &quot;simple&quot; substring tests. It
 /// also provides routines for easily running them on any substring search
 /// implementation.
 </span><span class="attribute">#[cfg(test)]
 </span><span class="kw">mod </span>testsimples {
     <span class="macro">define_memmem_simple_tests!</span>(<span class="kw">super</span>::find, <span class="kw">super</span>::rfind);

     <span class="doccomment">/// Each test is a (needle, haystack, expected_fwd, expected_rev) tuple.
     </span><span class="kw">type </span>SearchTest =
         (<span class="kw-2">&amp;</span><span class="lifetime">&#39;static </span>str, <span class="kw-2">&amp;</span><span class="lifetime">&#39;static </span>str, <span class="prelude-ty">Option</span>&lt;usize&gt;, <span class="prelude-ty">Option</span>&lt;usize&gt;);

     <span class="kw">const </span>SEARCH_TESTS: <span class="kw-2">&amp;</span><span class="lifetime">&#39;static </span>[SearchTest] = <span class="kw-2">&amp;</span>[
         (<span class="string">&quot;&quot;</span>, <span class="string">&quot;&quot;</span>, <span class="prelude-val">Some</span>(<span class="number">0</span>), <span class="prelude-val">Some</span>(<span class="number">0</span>)),
         (<span class="string">&quot;&quot;</span>, <span class="string">&quot;a&quot;</span>, <span class="prelude-val">Some</span>(<span class="number">0</span>), <span class="prelude-val">Some</span>(<span class="number">1</span>)),
         (<span class="string">&quot;&quot;</span>, <span class="string">&quot;ab&quot;</span>, <span class="prelude-val">Some</span>(<span class="number">0</span>), <span class="prelude-val">Some</span>(<span class="number">2</span>)),
         (<span class="string">&quot;&quot;</span>, <span class="string">&quot;abc&quot;</span>, <span class="prelude-val">Some</span>(<span class="number">0</span>), <span class="prelude-val">Some</span>(<span class="number">3</span>)),
         (<span class="string">&quot;a&quot;</span>, <span class="string">&quot;&quot;</span>, <span class="prelude-val">None</span>, <span class="prelude-val">None</span>),
         (<span class="string">&quot;a&quot;</span>, <span class="string">&quot;a&quot;</span>, <span class="prelude-val">Some</span>(<span class="number">0</span>), <span class="prelude-val">Some</span>(<span class="number">0</span>)),
         (<span class="string">&quot;a&quot;</span>, <span class="string">&quot;aa&quot;</span>, <span class="prelude-val">Some</span>(<span class="number">0</span>), <span class="prelude-val">Some</span>(<span class="number">1</span>)),
         (<span class="string">&quot;a&quot;</span>, <span class="string">&quot;ba&quot;</span>, <span class="prelude-val">Some</span>(<span class="number">1</span>), <span class="prelude-val">Some</span>(<span class="number">1</span>)),
         (<span class="string">&quot;a&quot;</span>, <span class="string">&quot;bba&quot;</span>, <span class="prelude-val">Some</span>(<span class="number">2</span>), <span class="prelude-val">Some</span>(<span class="number">2</span>)),
         (<span class="string">&quot;a&quot;</span>, <span class="string">&quot;bbba&quot;</span>, <span class="prelude-val">Some</span>(<span class="number">3</span>), <span class="prelude-val">Some</span>(<span class="number">3</span>)),
         (<span class="string">&quot;a&quot;</span>, <span class="string">&quot;bbbab&quot;</span>, <span class="prelude-val">Some</span>(<span class="number">3</span>), <span class="prelude-val">Some</span>(<span class="number">3</span>)),
         (<span class="string">&quot;a&quot;</span>, <span class="string">&quot;bbbabb&quot;</span>, <span class="prelude-val">Some</span>(<span class="number">3</span>), <span class="prelude-val">Some</span>(<span class="number">3</span>)),
         (<span class="string">&quot;a&quot;</span>, <span class="string">&quot;bbbabbb&quot;</span>, <span class="prelude-val">Some</span>(<span class="number">3</span>), <span class="prelude-val">Some</span>(<span class="number">3</span>)),
         (<span class="string">&quot;a&quot;</span>, <span class="string">&quot;bbbbbb&quot;</span>, <span class="prelude-val">None</span>, <span class="prelude-val">None</span>),
         (<span class="string">&quot;ab&quot;</span>, <span class="string">&quot;&quot;</span>, <span class="prelude-val">None</span>, <span class="prelude-val">None</span>),
         (<span class="string">&quot;ab&quot;</span>, <span class="string">&quot;a&quot;</span>, <span class="prelude-val">None</span>, <span class="prelude-val">None</span>),
         (<span class="string">&quot;ab&quot;</span>, <span class="string">&quot;b&quot;</span>, <span class="prelude-val">None</span>, <span class="prelude-val">None</span>),
         (<span class="string">&quot;ab&quot;</span>, <span class="string">&quot;ab&quot;</span>, <span class="prelude-val">Some</span>(<span class="number">0</span>), <span class="prelude-val">Some</span>(<span class="number">0</span>)),
         (<span class="string">&quot;ab&quot;</span>, <span class="string">&quot;aab&quot;</span>, <span class="prelude-val">Some</span>(<span class="number">1</span>), <span class="prelude-val">Some</span>(<span class="number">1</span>)),
         (<span class="string">&quot;ab&quot;</span>, <span class="string">&quot;aaab&quot;</span>, <span class="prelude-val">Some</span>(<span class="number">2</span>), <span class="prelude-val">Some</span>(<span class="number">2</span>)),
         (<span class="string">&quot;ab&quot;</span>, <span class="string">&quot;abaab&quot;</span>, <span class="prelude-val">Some</span>(<span class="number">0</span>), <span class="prelude-val">Some</span>(<span class="number">3</span>)),
         (<span class="string">&quot;ab&quot;</span>, <span class="string">&quot;baaab&quot;</span>, <span class="prelude-val">Some</span>(<span class="number">3</span>), <span class="prelude-val">Some</span>(<span class="number">3</span>)),
         (<span class="string">&quot;ab&quot;</span>, <span class="string">&quot;acb&quot;</span>, <span class="prelude-val">None</span>, <span class="prelude-val">None</span>),
         (<span class="string">&quot;ab&quot;</span>, <span class="string">&quot;abba&quot;</span>, <span class="prelude-val">Some</span>(<span class="number">0</span>), <span class="prelude-val">Some</span>(<span class="number">0</span>)),
         (<span class="string">&quot;abc&quot;</span>, <span class="string">&quot;ab&quot;</span>, <span class="prelude-val">None</span>, <span class="prelude-val">None</span>),
         (<span class="string">&quot;abc&quot;</span>, <span class="string">&quot;abc&quot;</span>, <span class="prelude-val">Some</span>(<span class="number">0</span>), <span class="prelude-val">Some</span>(<span class="number">0</span>)),
         (<span class="string">&quot;abc&quot;</span>, <span class="string">&quot;abcz&quot;</span>, <span class="prelude-val">Some</span>(<span class="number">0</span>), <span class="prelude-val">Some</span>(<span class="number">0</span>)),
         (<span class="string">&quot;abc&quot;</span>, <span class="string">&quot;abczz&quot;</span>, <span class="prelude-val">Some</span>(<span class="number">0</span>), <span class="prelude-val">Some</span>(<span class="number">0</span>)),
         (<span class="string">&quot;abc&quot;</span>, <span class="string">&quot;zabc&quot;</span>, <span class="prelude-val">Some</span>(<span class="number">1</span>), <span class="prelude-val">Some</span>(<span class="number">1</span>)),
         (<span class="string">&quot;abc&quot;</span>, <span class="string">&quot;zzabc&quot;</span>, <span class="prelude-val">Some</span>(<span class="number">2</span>), <span class="prelude-val">Some</span>(<span class="number">2</span>)),
         (<span class="string">&quot;abc&quot;</span>, <span class="string">&quot;azbc&quot;</span>, <span class="prelude-val">None</span>, <span class="prelude-val">None</span>),
         (<span class="string">&quot;abc&quot;</span>, <span class="string">&quot;abzc&quot;</span>, <span class="prelude-val">None</span>, <span class="prelude-val">None</span>),
         (<span class="string">&quot;abczdef&quot;</span>, <span class="string">&quot;abczdefzzzzzzzzzzzzzzzzzzzz&quot;</span>, <span class="prelude-val">Some</span>(<span class="number">0</span>), <span class="prelude-val">Some</span>(<span class="number">0</span>)),
         (<span class="string">&quot;abczdef&quot;</span>, <span class="string">&quot;zzzzzzzzzzzzzzzzzzzzabczdef&quot;</span>, <span class="prelude-val">Some</span>(<span class="number">20</span>), <span class="prelude-val">Some</span>(<span class="number">20</span>)),
         (<span class="string">&quot;xyz&quot;</span>, <span class="string">&quot;aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaxyz&quot;</span>, <span class="prelude-val">Some</span>(<span class="number">32</span>), <span class="prelude-val">Some</span>(<span class="number">32</span>)),
         <span class="comment">// Failures caught by quickcheck.
         </span>(<span class="string">&quot;\u{0}\u{15}&quot;</span>, <span class="string">&quot;\u{0}\u{15}\u{15}\u{0}&quot;</span>, <span class="prelude-val">Some</span>(<span class="number">0</span>), <span class="prelude-val">Some</span>(<span class="number">0</span>)),
         (<span class="string">&quot;\u{0}\u{1e}&quot;</span>, <span class="string">&quot;\u{1e}\u{0}&quot;</span>, <span class="prelude-val">None</span>, <span class="prelude-val">None</span>),
     ];

     <span class="doccomment">/// Run the substring search tests. `search` should be a closure that
     /// accepts a haystack and a needle and returns the starting position
     /// of the first occurrence of needle in the haystack, or `None` if one
     /// doesn&#39;t exist.
     </span><span class="kw">pub</span>(<span class="kw">crate</span>) <span class="kw">fn </span>run_search_tests_fwd(
         <span class="kw-2">mut </span>search: <span class="kw">impl </span>FnMut(<span class="kw-2">&amp;</span>[u8], <span class="kw-2">&amp;</span>[u8]) -&gt; <span class="prelude-ty">Option</span>&lt;usize&gt;,
     ) {
         <span class="kw">for </span><span class="kw-2">&amp;</span>(needle, haystack, expected_fwd, <span class="kw">_</span>) <span class="kw">in </span>SEARCH_TESTS {
             <span class="kw">let </span>(n, h) = (needle.as_bytes(), haystack.as_bytes());
             <span class="macro">assert_eq!</span>(
                 expected_fwd,
                 search(h, n),
                 <span class="string">&quot;needle: {:?}, haystack: {:?}, expected: {:?}&quot;</span>,
                 n,
                 h,
                 expected_fwd
             );
         }
     }

     <span class="doccomment">/// Run the substring search tests. `search` should be a closure that
     /// accepts a haystack and a needle and returns the starting position of
     /// the last occurrence of needle in the haystack, or `None` if one doesn&#39;t
     /// exist.
     </span><span class="kw">pub</span>(<span class="kw">crate</span>) <span class="kw">fn </span>run_search_tests_rev(
         <span class="kw-2">mut </span>search: <span class="kw">impl </span>FnMut(<span class="kw-2">&amp;</span>[u8], <span class="kw-2">&amp;</span>[u8]) -&gt; <span class="prelude-ty">Option</span>&lt;usize&gt;,
     ) {
         <span class="kw">for </span><span class="kw-2">&amp;</span>(needle, haystack, <span class="kw">_</span>, expected_rev) <span class="kw">in </span>SEARCH_TESTS {
             <span class="kw">let </span>(n, h) = (needle.as_bytes(), haystack.as_bytes());
             <span class="macro">assert_eq!</span>(
                 expected_rev,
                 search(h, n),
                 <span class="string">&quot;needle: {:?}, haystack: {:?}, expected: {:?}&quot;</span>,
                 n,
                 h,
                 expected_rev
             );
         }
     }
 }
 </code></pre></div>
 </section></div></main><div id="rustdoc-vars" data-root-path="../../../" data-current-crate="memchr" data-themes="ayu,dark,light" data-resource-suffix="" data-rustdoc-version="1.66.0-nightly (5c8bff74b 2022-10-21)" ></div></body></html>