blob: 3b1f5dac430e491ce05d3575fea2b445d090d37a [file] [log] [blame]
<!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/raw-cpuid-10.7.0/src/lib.rs`."><meta name="keywords" content="rust, rustlang, rust-lang"><title>lib.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="../../raw_cpuid/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="../../raw_cpuid/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>
<span id="1322">1322</span>
<span id="1323">1323</span>
<span id="1324">1324</span>
<span id="1325">1325</span>
<span id="1326">1326</span>
<span id="1327">1327</span>
<span id="1328">1328</span>
<span id="1329">1329</span>
<span id="1330">1330</span>
<span id="1331">1331</span>
<span id="1332">1332</span>
<span id="1333">1333</span>
<span id="1334">1334</span>
<span id="1335">1335</span>
<span id="1336">1336</span>
<span id="1337">1337</span>
<span id="1338">1338</span>
<span id="1339">1339</span>
<span id="1340">1340</span>
<span id="1341">1341</span>
<span id="1342">1342</span>
<span id="1343">1343</span>
<span id="1344">1344</span>
<span id="1345">1345</span>
<span id="1346">1346</span>
<span id="1347">1347</span>
<span id="1348">1348</span>
<span id="1349">1349</span>
<span id="1350">1350</span>
<span id="1351">1351</span>
<span id="1352">1352</span>
<span id="1353">1353</span>
<span id="1354">1354</span>
<span id="1355">1355</span>
<span id="1356">1356</span>
<span id="1357">1357</span>
<span id="1358">1358</span>
<span id="1359">1359</span>
<span id="1360">1360</span>
<span id="1361">1361</span>
<span id="1362">1362</span>
<span id="1363">1363</span>
<span id="1364">1364</span>
<span id="1365">1365</span>
<span id="1366">1366</span>
<span id="1367">1367</span>
<span id="1368">1368</span>
<span id="1369">1369</span>
<span id="1370">1370</span>
<span id="1371">1371</span>
<span id="1372">1372</span>
<span id="1373">1373</span>
<span id="1374">1374</span>
<span id="1375">1375</span>
<span id="1376">1376</span>
<span id="1377">1377</span>
<span id="1378">1378</span>
<span id="1379">1379</span>
<span id="1380">1380</span>
<span id="1381">1381</span>
<span id="1382">1382</span>
<span id="1383">1383</span>
<span id="1384">1384</span>
<span id="1385">1385</span>
<span id="1386">1386</span>
<span id="1387">1387</span>
<span id="1388">1388</span>
<span id="1389">1389</span>
<span id="1390">1390</span>
<span id="1391">1391</span>
<span id="1392">1392</span>
<span id="1393">1393</span>
<span id="1394">1394</span>
<span id="1395">1395</span>
<span id="1396">1396</span>
<span id="1397">1397</span>
<span id="1398">1398</span>
<span id="1399">1399</span>
<span id="1400">1400</span>
<span id="1401">1401</span>
<span id="1402">1402</span>
<span id="1403">1403</span>
<span id="1404">1404</span>
<span id="1405">1405</span>
<span id="1406">1406</span>
<span id="1407">1407</span>
<span id="1408">1408</span>
<span id="1409">1409</span>
<span id="1410">1410</span>
<span id="1411">1411</span>
<span id="1412">1412</span>
<span id="1413">1413</span>
<span id="1414">1414</span>
<span id="1415">1415</span>
<span id="1416">1416</span>
<span id="1417">1417</span>
<span id="1418">1418</span>
<span id="1419">1419</span>
<span id="1420">1420</span>
<span id="1421">1421</span>
<span id="1422">1422</span>
<span id="1423">1423</span>
<span id="1424">1424</span>
<span id="1425">1425</span>
<span id="1426">1426</span>
<span id="1427">1427</span>
<span id="1428">1428</span>
<span id="1429">1429</span>
<span id="1430">1430</span>
<span id="1431">1431</span>
<span id="1432">1432</span>
<span id="1433">1433</span>
<span id="1434">1434</span>
<span id="1435">1435</span>
<span id="1436">1436</span>
<span id="1437">1437</span>
<span id="1438">1438</span>
<span id="1439">1439</span>
<span id="1440">1440</span>
<span id="1441">1441</span>
<span id="1442">1442</span>
<span id="1443">1443</span>
<span id="1444">1444</span>
<span id="1445">1445</span>
<span id="1446">1446</span>
<span id="1447">1447</span>
<span id="1448">1448</span>
<span id="1449">1449</span>
<span id="1450">1450</span>
<span id="1451">1451</span>
<span id="1452">1452</span>
<span id="1453">1453</span>
<span id="1454">1454</span>
<span id="1455">1455</span>
<span id="1456">1456</span>
<span id="1457">1457</span>
<span id="1458">1458</span>
<span id="1459">1459</span>
<span id="1460">1460</span>
<span id="1461">1461</span>
<span id="1462">1462</span>
<span id="1463">1463</span>
<span id="1464">1464</span>
<span id="1465">1465</span>
<span id="1466">1466</span>
<span id="1467">1467</span>
<span id="1468">1468</span>
<span id="1469">1469</span>
<span id="1470">1470</span>
<span id="1471">1471</span>
<span id="1472">1472</span>
<span id="1473">1473</span>
<span id="1474">1474</span>
<span id="1475">1475</span>
<span id="1476">1476</span>
<span id="1477">1477</span>
<span id="1478">1478</span>
<span id="1479">1479</span>
<span id="1480">1480</span>
<span id="1481">1481</span>
<span id="1482">1482</span>
<span id="1483">1483</span>
<span id="1484">1484</span>
<span id="1485">1485</span>
<span id="1486">1486</span>
<span id="1487">1487</span>
<span id="1488">1488</span>
<span id="1489">1489</span>
<span id="1490">1490</span>
<span id="1491">1491</span>
<span id="1492">1492</span>
<span id="1493">1493</span>
<span id="1494">1494</span>
<span id="1495">1495</span>
<span id="1496">1496</span>
<span id="1497">1497</span>
<span id="1498">1498</span>
<span id="1499">1499</span>
<span id="1500">1500</span>
<span id="1501">1501</span>
<span id="1502">1502</span>
<span id="1503">1503</span>
<span id="1504">1504</span>
<span id="1505">1505</span>
<span id="1506">1506</span>
<span id="1507">1507</span>
<span id="1508">1508</span>
<span id="1509">1509</span>
<span id="1510">1510</span>
<span id="1511">1511</span>
<span id="1512">1512</span>
<span id="1513">1513</span>
<span id="1514">1514</span>
<span id="1515">1515</span>
<span id="1516">1516</span>
<span id="1517">1517</span>
<span id="1518">1518</span>
<span id="1519">1519</span>
<span id="1520">1520</span>
<span id="1521">1521</span>
<span id="1522">1522</span>
<span id="1523">1523</span>
<span id="1524">1524</span>
<span id="1525">1525</span>
<span id="1526">1526</span>
<span id="1527">1527</span>
<span id="1528">1528</span>
<span id="1529">1529</span>
<span id="1530">1530</span>
<span id="1531">1531</span>
<span id="1532">1532</span>
<span id="1533">1533</span>
<span id="1534">1534</span>
<span id="1535">1535</span>
<span id="1536">1536</span>
<span id="1537">1537</span>
<span id="1538">1538</span>
<span id="1539">1539</span>
<span id="1540">1540</span>
<span id="1541">1541</span>
<span id="1542">1542</span>
<span id="1543">1543</span>
<span id="1544">1544</span>
<span id="1545">1545</span>
<span id="1546">1546</span>
<span id="1547">1547</span>
<span id="1548">1548</span>
<span id="1549">1549</span>
<span id="1550">1550</span>
<span id="1551">1551</span>
<span id="1552">1552</span>
<span id="1553">1553</span>
<span id="1554">1554</span>
<span id="1555">1555</span>
<span id="1556">1556</span>
<span id="1557">1557</span>
<span id="1558">1558</span>
<span id="1559">1559</span>
<span id="1560">1560</span>
<span id="1561">1561</span>
<span id="1562">1562</span>
<span id="1563">1563</span>
<span id="1564">1564</span>
<span id="1565">1565</span>
<span id="1566">1566</span>
<span id="1567">1567</span>
<span id="1568">1568</span>
<span id="1569">1569</span>
<span id="1570">1570</span>
<span id="1571">1571</span>
<span id="1572">1572</span>
<span id="1573">1573</span>
<span id="1574">1574</span>
<span id="1575">1575</span>
<span id="1576">1576</span>
<span id="1577">1577</span>
<span id="1578">1578</span>
<span id="1579">1579</span>
<span id="1580">1580</span>
<span id="1581">1581</span>
<span id="1582">1582</span>
<span id="1583">1583</span>
<span id="1584">1584</span>
<span id="1585">1585</span>
<span id="1586">1586</span>
<span id="1587">1587</span>
<span id="1588">1588</span>
<span id="1589">1589</span>
<span id="1590">1590</span>
<span id="1591">1591</span>
<span id="1592">1592</span>
<span id="1593">1593</span>
<span id="1594">1594</span>
<span id="1595">1595</span>
<span id="1596">1596</span>
<span id="1597">1597</span>
<span id="1598">1598</span>
<span id="1599">1599</span>
<span id="1600">1600</span>
<span id="1601">1601</span>
<span id="1602">1602</span>
<span id="1603">1603</span>
<span id="1604">1604</span>
<span id="1605">1605</span>
<span id="1606">1606</span>
<span id="1607">1607</span>
<span id="1608">1608</span>
<span id="1609">1609</span>
<span id="1610">1610</span>
<span id="1611">1611</span>
<span id="1612">1612</span>
<span id="1613">1613</span>
<span id="1614">1614</span>
<span id="1615">1615</span>
<span id="1616">1616</span>
<span id="1617">1617</span>
<span id="1618">1618</span>
<span id="1619">1619</span>
<span id="1620">1620</span>
<span id="1621">1621</span>
<span id="1622">1622</span>
<span id="1623">1623</span>
<span id="1624">1624</span>
<span id="1625">1625</span>
<span id="1626">1626</span>
<span id="1627">1627</span>
<span id="1628">1628</span>
<span id="1629">1629</span>
<span id="1630">1630</span>
<span id="1631">1631</span>
<span id="1632">1632</span>
<span id="1633">1633</span>
<span id="1634">1634</span>
<span id="1635">1635</span>
<span id="1636">1636</span>
<span id="1637">1637</span>
<span id="1638">1638</span>
<span id="1639">1639</span>
<span id="1640">1640</span>
<span id="1641">1641</span>
<span id="1642">1642</span>
<span id="1643">1643</span>
<span id="1644">1644</span>
<span id="1645">1645</span>
<span id="1646">1646</span>
<span id="1647">1647</span>
<span id="1648">1648</span>
<span id="1649">1649</span>
<span id="1650">1650</span>
<span id="1651">1651</span>
<span id="1652">1652</span>
<span id="1653">1653</span>
<span id="1654">1654</span>
<span id="1655">1655</span>
<span id="1656">1656</span>
<span id="1657">1657</span>
<span id="1658">1658</span>
<span id="1659">1659</span>
<span id="1660">1660</span>
<span id="1661">1661</span>
<span id="1662">1662</span>
<span id="1663">1663</span>
<span id="1664">1664</span>
<span id="1665">1665</span>
<span id="1666">1666</span>
<span id="1667">1667</span>
<span id="1668">1668</span>
<span id="1669">1669</span>
<span id="1670">1670</span>
<span id="1671">1671</span>
<span id="1672">1672</span>
<span id="1673">1673</span>
<span id="1674">1674</span>
<span id="1675">1675</span>
<span id="1676">1676</span>
<span id="1677">1677</span>
<span id="1678">1678</span>
<span id="1679">1679</span>
<span id="1680">1680</span>
<span id="1681">1681</span>
<span id="1682">1682</span>
<span id="1683">1683</span>
<span id="1684">1684</span>
<span id="1685">1685</span>
<span id="1686">1686</span>
<span id="1687">1687</span>
<span id="1688">1688</span>
<span id="1689">1689</span>
<span id="1690">1690</span>
<span id="1691">1691</span>
<span id="1692">1692</span>
<span id="1693">1693</span>
<span id="1694">1694</span>
<span id="1695">1695</span>
<span id="1696">1696</span>
<span id="1697">1697</span>
<span id="1698">1698</span>
<span id="1699">1699</span>
<span id="1700">1700</span>
<span id="1701">1701</span>
<span id="1702">1702</span>
<span id="1703">1703</span>
<span id="1704">1704</span>
<span id="1705">1705</span>
<span id="1706">1706</span>
<span id="1707">1707</span>
<span id="1708">1708</span>
<span id="1709">1709</span>
<span id="1710">1710</span>
<span id="1711">1711</span>
<span id="1712">1712</span>
<span id="1713">1713</span>
<span id="1714">1714</span>
<span id="1715">1715</span>
<span id="1716">1716</span>
<span id="1717">1717</span>
<span id="1718">1718</span>
<span id="1719">1719</span>
<span id="1720">1720</span>
<span id="1721">1721</span>
<span id="1722">1722</span>
<span id="1723">1723</span>
<span id="1724">1724</span>
<span id="1725">1725</span>
<span id="1726">1726</span>
<span id="1727">1727</span>
<span id="1728">1728</span>
<span id="1729">1729</span>
<span id="1730">1730</span>
<span id="1731">1731</span>
<span id="1732">1732</span>
<span id="1733">1733</span>
<span id="1734">1734</span>
<span id="1735">1735</span>
<span id="1736">1736</span>
<span id="1737">1737</span>
<span id="1738">1738</span>
<span id="1739">1739</span>
<span id="1740">1740</span>
<span id="1741">1741</span>
<span id="1742">1742</span>
<span id="1743">1743</span>
<span id="1744">1744</span>
<span id="1745">1745</span>
<span id="1746">1746</span>
<span id="1747">1747</span>
<span id="1748">1748</span>
<span id="1749">1749</span>
<span id="1750">1750</span>
<span id="1751">1751</span>
<span id="1752">1752</span>
<span id="1753">1753</span>
<span id="1754">1754</span>
<span id="1755">1755</span>
<span id="1756">1756</span>
<span id="1757">1757</span>
<span id="1758">1758</span>
<span id="1759">1759</span>
<span id="1760">1760</span>
<span id="1761">1761</span>
<span id="1762">1762</span>
<span id="1763">1763</span>
<span id="1764">1764</span>
<span id="1765">1765</span>
<span id="1766">1766</span>
<span id="1767">1767</span>
<span id="1768">1768</span>
<span id="1769">1769</span>
<span id="1770">1770</span>
<span id="1771">1771</span>
<span id="1772">1772</span>
<span id="1773">1773</span>
<span id="1774">1774</span>
<span id="1775">1775</span>
<span id="1776">1776</span>
<span id="1777">1777</span>
<span id="1778">1778</span>
<span id="1779">1779</span>
<span id="1780">1780</span>
<span id="1781">1781</span>
<span id="1782">1782</span>
<span id="1783">1783</span>
<span id="1784">1784</span>
<span id="1785">1785</span>
<span id="1786">1786</span>
<span id="1787">1787</span>
<span id="1788">1788</span>
<span id="1789">1789</span>
<span id="1790">1790</span>
<span id="1791">1791</span>
<span id="1792">1792</span>
<span id="1793">1793</span>
<span id="1794">1794</span>
<span id="1795">1795</span>
<span id="1796">1796</span>
<span id="1797">1797</span>
<span id="1798">1798</span>
<span id="1799">1799</span>
<span id="1800">1800</span>
<span id="1801">1801</span>
<span id="1802">1802</span>
<span id="1803">1803</span>
<span id="1804">1804</span>
<span id="1805">1805</span>
<span id="1806">1806</span>
<span id="1807">1807</span>
<span id="1808">1808</span>
<span id="1809">1809</span>
<span id="1810">1810</span>
<span id="1811">1811</span>
<span id="1812">1812</span>
<span id="1813">1813</span>
<span id="1814">1814</span>
<span id="1815">1815</span>
<span id="1816">1816</span>
<span id="1817">1817</span>
<span id="1818">1818</span>
<span id="1819">1819</span>
<span id="1820">1820</span>
<span id="1821">1821</span>
<span id="1822">1822</span>
<span id="1823">1823</span>
<span id="1824">1824</span>
<span id="1825">1825</span>
<span id="1826">1826</span>
<span id="1827">1827</span>
<span id="1828">1828</span>
<span id="1829">1829</span>
<span id="1830">1830</span>
<span id="1831">1831</span>
<span id="1832">1832</span>
<span id="1833">1833</span>
<span id="1834">1834</span>
<span id="1835">1835</span>
<span id="1836">1836</span>
<span id="1837">1837</span>
<span id="1838">1838</span>
<span id="1839">1839</span>
<span id="1840">1840</span>
<span id="1841">1841</span>
<span id="1842">1842</span>
<span id="1843">1843</span>
<span id="1844">1844</span>
<span id="1845">1845</span>
<span id="1846">1846</span>
<span id="1847">1847</span>
<span id="1848">1848</span>
<span id="1849">1849</span>
<span id="1850">1850</span>
<span id="1851">1851</span>
<span id="1852">1852</span>
<span id="1853">1853</span>
<span id="1854">1854</span>
<span id="1855">1855</span>
<span id="1856">1856</span>
<span id="1857">1857</span>
<span id="1858">1858</span>
<span id="1859">1859</span>
<span id="1860">1860</span>
<span id="1861">1861</span>
<span id="1862">1862</span>
<span id="1863">1863</span>
<span id="1864">1864</span>
<span id="1865">1865</span>
<span id="1866">1866</span>
<span id="1867">1867</span>
<span id="1868">1868</span>
<span id="1869">1869</span>
<span id="1870">1870</span>
<span id="1871">1871</span>
<span id="1872">1872</span>
<span id="1873">1873</span>
<span id="1874">1874</span>
<span id="1875">1875</span>
<span id="1876">1876</span>
<span id="1877">1877</span>
<span id="1878">1878</span>
<span id="1879">1879</span>
<span id="1880">1880</span>
<span id="1881">1881</span>
<span id="1882">1882</span>
<span id="1883">1883</span>
<span id="1884">1884</span>
<span id="1885">1885</span>
<span id="1886">1886</span>
<span id="1887">1887</span>
<span id="1888">1888</span>
<span id="1889">1889</span>
<span id="1890">1890</span>
<span id="1891">1891</span>
<span id="1892">1892</span>
<span id="1893">1893</span>
<span id="1894">1894</span>
<span id="1895">1895</span>
<span id="1896">1896</span>
<span id="1897">1897</span>
<span id="1898">1898</span>
<span id="1899">1899</span>
<span id="1900">1900</span>
<span id="1901">1901</span>
<span id="1902">1902</span>
<span id="1903">1903</span>
<span id="1904">1904</span>
<span id="1905">1905</span>
<span id="1906">1906</span>
<span id="1907">1907</span>
<span id="1908">1908</span>
<span id="1909">1909</span>
<span id="1910">1910</span>
<span id="1911">1911</span>
<span id="1912">1912</span>
<span id="1913">1913</span>
<span id="1914">1914</span>
<span id="1915">1915</span>
<span id="1916">1916</span>
<span id="1917">1917</span>
<span id="1918">1918</span>
<span id="1919">1919</span>
<span id="1920">1920</span>
<span id="1921">1921</span>
<span id="1922">1922</span>
<span id="1923">1923</span>
<span id="1924">1924</span>
<span id="1925">1925</span>
<span id="1926">1926</span>
<span id="1927">1927</span>
<span id="1928">1928</span>
<span id="1929">1929</span>
<span id="1930">1930</span>
<span id="1931">1931</span>
<span id="1932">1932</span>
<span id="1933">1933</span>
<span id="1934">1934</span>
<span id="1935">1935</span>
<span id="1936">1936</span>
<span id="1937">1937</span>
<span id="1938">1938</span>
<span id="1939">1939</span>
<span id="1940">1940</span>
<span id="1941">1941</span>
<span id="1942">1942</span>
<span id="1943">1943</span>
<span id="1944">1944</span>
<span id="1945">1945</span>
<span id="1946">1946</span>
<span id="1947">1947</span>
<span id="1948">1948</span>
<span id="1949">1949</span>
<span id="1950">1950</span>
<span id="1951">1951</span>
<span id="1952">1952</span>
<span id="1953">1953</span>
<span id="1954">1954</span>
<span id="1955">1955</span>
<span id="1956">1956</span>
<span id="1957">1957</span>
<span id="1958">1958</span>
<span id="1959">1959</span>
<span id="1960">1960</span>
<span id="1961">1961</span>
<span id="1962">1962</span>
<span id="1963">1963</span>
<span id="1964">1964</span>
<span id="1965">1965</span>
<span id="1966">1966</span>
<span id="1967">1967</span>
<span id="1968">1968</span>
<span id="1969">1969</span>
<span id="1970">1970</span>
<span id="1971">1971</span>
<span id="1972">1972</span>
<span id="1973">1973</span>
<span id="1974">1974</span>
<span id="1975">1975</span>
<span id="1976">1976</span>
<span id="1977">1977</span>
<span id="1978">1978</span>
<span id="1979">1979</span>
<span id="1980">1980</span>
<span id="1981">1981</span>
<span id="1982">1982</span>
<span id="1983">1983</span>
<span id="1984">1984</span>
<span id="1985">1985</span>
<span id="1986">1986</span>
<span id="1987">1987</span>
<span id="1988">1988</span>
<span id="1989">1989</span>
<span id="1990">1990</span>
<span id="1991">1991</span>
<span id="1992">1992</span>
<span id="1993">1993</span>
<span id="1994">1994</span>
<span id="1995">1995</span>
<span id="1996">1996</span>
<span id="1997">1997</span>
<span id="1998">1998</span>
<span id="1999">1999</span>
<span id="2000">2000</span>
<span id="2001">2001</span>
<span id="2002">2002</span>
<span id="2003">2003</span>
<span id="2004">2004</span>
<span id="2005">2005</span>
<span id="2006">2006</span>
<span id="2007">2007</span>
<span id="2008">2008</span>
<span id="2009">2009</span>
<span id="2010">2010</span>
<span id="2011">2011</span>
<span id="2012">2012</span>
<span id="2013">2013</span>
<span id="2014">2014</span>
<span id="2015">2015</span>
<span id="2016">2016</span>
<span id="2017">2017</span>
<span id="2018">2018</span>
<span id="2019">2019</span>
<span id="2020">2020</span>
<span id="2021">2021</span>
<span id="2022">2022</span>
<span id="2023">2023</span>
<span id="2024">2024</span>
<span id="2025">2025</span>
<span id="2026">2026</span>
<span id="2027">2027</span>
<span id="2028">2028</span>
<span id="2029">2029</span>
<span id="2030">2030</span>
<span id="2031">2031</span>
<span id="2032">2032</span>
<span id="2033">2033</span>
<span id="2034">2034</span>
<span id="2035">2035</span>
<span id="2036">2036</span>
<span id="2037">2037</span>
<span id="2038">2038</span>
<span id="2039">2039</span>
<span id="2040">2040</span>
<span id="2041">2041</span>
<span id="2042">2042</span>
<span id="2043">2043</span>
<span id="2044">2044</span>
<span id="2045">2045</span>
<span id="2046">2046</span>
<span id="2047">2047</span>
<span id="2048">2048</span>
<span id="2049">2049</span>
<span id="2050">2050</span>
<span id="2051">2051</span>
<span id="2052">2052</span>
<span id="2053">2053</span>
<span id="2054">2054</span>
<span id="2055">2055</span>
<span id="2056">2056</span>
<span id="2057">2057</span>
<span id="2058">2058</span>
<span id="2059">2059</span>
<span id="2060">2060</span>
<span id="2061">2061</span>
<span id="2062">2062</span>
<span id="2063">2063</span>
<span id="2064">2064</span>
<span id="2065">2065</span>
<span id="2066">2066</span>
<span id="2067">2067</span>
<span id="2068">2068</span>
<span id="2069">2069</span>
<span id="2070">2070</span>
<span id="2071">2071</span>
<span id="2072">2072</span>
<span id="2073">2073</span>
<span id="2074">2074</span>
<span id="2075">2075</span>
<span id="2076">2076</span>
<span id="2077">2077</span>
<span id="2078">2078</span>
<span id="2079">2079</span>
<span id="2080">2080</span>
<span id="2081">2081</span>
<span id="2082">2082</span>
<span id="2083">2083</span>
<span id="2084">2084</span>
<span id="2085">2085</span>
<span id="2086">2086</span>
<span id="2087">2087</span>
<span id="2088">2088</span>
<span id="2089">2089</span>
<span id="2090">2090</span>
<span id="2091">2091</span>
<span id="2092">2092</span>
<span id="2093">2093</span>
<span id="2094">2094</span>
<span id="2095">2095</span>
<span id="2096">2096</span>
<span id="2097">2097</span>
<span id="2098">2098</span>
<span id="2099">2099</span>
<span id="2100">2100</span>
<span id="2101">2101</span>
<span id="2102">2102</span>
<span id="2103">2103</span>
<span id="2104">2104</span>
<span id="2105">2105</span>
<span id="2106">2106</span>
<span id="2107">2107</span>
<span id="2108">2108</span>
<span id="2109">2109</span>
<span id="2110">2110</span>
<span id="2111">2111</span>
<span id="2112">2112</span>
<span id="2113">2113</span>
<span id="2114">2114</span>
<span id="2115">2115</span>
<span id="2116">2116</span>
<span id="2117">2117</span>
<span id="2118">2118</span>
<span id="2119">2119</span>
<span id="2120">2120</span>
<span id="2121">2121</span>
<span id="2122">2122</span>
<span id="2123">2123</span>
<span id="2124">2124</span>
<span id="2125">2125</span>
<span id="2126">2126</span>
<span id="2127">2127</span>
<span id="2128">2128</span>
<span id="2129">2129</span>
<span id="2130">2130</span>
<span id="2131">2131</span>
<span id="2132">2132</span>
<span id="2133">2133</span>
<span id="2134">2134</span>
<span id="2135">2135</span>
<span id="2136">2136</span>
<span id="2137">2137</span>
<span id="2138">2138</span>
<span id="2139">2139</span>
<span id="2140">2140</span>
<span id="2141">2141</span>
<span id="2142">2142</span>
<span id="2143">2143</span>
<span id="2144">2144</span>
<span id="2145">2145</span>
<span id="2146">2146</span>
<span id="2147">2147</span>
<span id="2148">2148</span>
<span id="2149">2149</span>
<span id="2150">2150</span>
<span id="2151">2151</span>
<span id="2152">2152</span>
<span id="2153">2153</span>
<span id="2154">2154</span>
<span id="2155">2155</span>
<span id="2156">2156</span>
<span id="2157">2157</span>
<span id="2158">2158</span>
<span id="2159">2159</span>
<span id="2160">2160</span>
<span id="2161">2161</span>
<span id="2162">2162</span>
<span id="2163">2163</span>
<span id="2164">2164</span>
<span id="2165">2165</span>
<span id="2166">2166</span>
<span id="2167">2167</span>
<span id="2168">2168</span>
<span id="2169">2169</span>
<span id="2170">2170</span>
<span id="2171">2171</span>
<span id="2172">2172</span>
<span id="2173">2173</span>
<span id="2174">2174</span>
<span id="2175">2175</span>
<span id="2176">2176</span>
<span id="2177">2177</span>
<span id="2178">2178</span>
<span id="2179">2179</span>
<span id="2180">2180</span>
<span id="2181">2181</span>
<span id="2182">2182</span>
<span id="2183">2183</span>
<span id="2184">2184</span>
<span id="2185">2185</span>
<span id="2186">2186</span>
<span id="2187">2187</span>
<span id="2188">2188</span>
<span id="2189">2189</span>
<span id="2190">2190</span>
<span id="2191">2191</span>
<span id="2192">2192</span>
<span id="2193">2193</span>
<span id="2194">2194</span>
<span id="2195">2195</span>
<span id="2196">2196</span>
<span id="2197">2197</span>
<span id="2198">2198</span>
<span id="2199">2199</span>
<span id="2200">2200</span>
<span id="2201">2201</span>
<span id="2202">2202</span>
<span id="2203">2203</span>
<span id="2204">2204</span>
<span id="2205">2205</span>
<span id="2206">2206</span>
<span id="2207">2207</span>
<span id="2208">2208</span>
<span id="2209">2209</span>
<span id="2210">2210</span>
<span id="2211">2211</span>
<span id="2212">2212</span>
<span id="2213">2213</span>
<span id="2214">2214</span>
<span id="2215">2215</span>
<span id="2216">2216</span>
<span id="2217">2217</span>
<span id="2218">2218</span>
<span id="2219">2219</span>
<span id="2220">2220</span>
<span id="2221">2221</span>
<span id="2222">2222</span>
<span id="2223">2223</span>
<span id="2224">2224</span>
<span id="2225">2225</span>
<span id="2226">2226</span>
<span id="2227">2227</span>
<span id="2228">2228</span>
<span id="2229">2229</span>
<span id="2230">2230</span>
<span id="2231">2231</span>
<span id="2232">2232</span>
<span id="2233">2233</span>
<span id="2234">2234</span>
<span id="2235">2235</span>
<span id="2236">2236</span>
<span id="2237">2237</span>
<span id="2238">2238</span>
<span id="2239">2239</span>
<span id="2240">2240</span>
<span id="2241">2241</span>
<span id="2242">2242</span>
<span id="2243">2243</span>
<span id="2244">2244</span>
<span id="2245">2245</span>
<span id="2246">2246</span>
<span id="2247">2247</span>
<span id="2248">2248</span>
<span id="2249">2249</span>
<span id="2250">2250</span>
<span id="2251">2251</span>
<span id="2252">2252</span>
<span id="2253">2253</span>
<span id="2254">2254</span>
<span id="2255">2255</span>
<span id="2256">2256</span>
<span id="2257">2257</span>
<span id="2258">2258</span>
<span id="2259">2259</span>
<span id="2260">2260</span>
<span id="2261">2261</span>
<span id="2262">2262</span>
<span id="2263">2263</span>
<span id="2264">2264</span>
<span id="2265">2265</span>
<span id="2266">2266</span>
<span id="2267">2267</span>
<span id="2268">2268</span>
<span id="2269">2269</span>
<span id="2270">2270</span>
<span id="2271">2271</span>
<span id="2272">2272</span>
<span id="2273">2273</span>
<span id="2274">2274</span>
<span id="2275">2275</span>
<span id="2276">2276</span>
<span id="2277">2277</span>
<span id="2278">2278</span>
<span id="2279">2279</span>
<span id="2280">2280</span>
<span id="2281">2281</span>
<span id="2282">2282</span>
<span id="2283">2283</span>
<span id="2284">2284</span>
<span id="2285">2285</span>
<span id="2286">2286</span>
<span id="2287">2287</span>
<span id="2288">2288</span>
<span id="2289">2289</span>
<span id="2290">2290</span>
<span id="2291">2291</span>
<span id="2292">2292</span>
<span id="2293">2293</span>
<span id="2294">2294</span>
<span id="2295">2295</span>
<span id="2296">2296</span>
<span id="2297">2297</span>
<span id="2298">2298</span>
<span id="2299">2299</span>
<span id="2300">2300</span>
<span id="2301">2301</span>
<span id="2302">2302</span>
<span id="2303">2303</span>
<span id="2304">2304</span>
<span id="2305">2305</span>
<span id="2306">2306</span>
<span id="2307">2307</span>
<span id="2308">2308</span>
<span id="2309">2309</span>
<span id="2310">2310</span>
<span id="2311">2311</span>
<span id="2312">2312</span>
<span id="2313">2313</span>
<span id="2314">2314</span>
<span id="2315">2315</span>
<span id="2316">2316</span>
<span id="2317">2317</span>
<span id="2318">2318</span>
<span id="2319">2319</span>
<span id="2320">2320</span>
<span id="2321">2321</span>
<span id="2322">2322</span>
<span id="2323">2323</span>
<span id="2324">2324</span>
<span id="2325">2325</span>
<span id="2326">2326</span>
<span id="2327">2327</span>
<span id="2328">2328</span>
<span id="2329">2329</span>
<span id="2330">2330</span>
<span id="2331">2331</span>
<span id="2332">2332</span>
<span id="2333">2333</span>
<span id="2334">2334</span>
<span id="2335">2335</span>
<span id="2336">2336</span>
<span id="2337">2337</span>
<span id="2338">2338</span>
<span id="2339">2339</span>
<span id="2340">2340</span>
<span id="2341">2341</span>
<span id="2342">2342</span>
<span id="2343">2343</span>
<span id="2344">2344</span>
<span id="2345">2345</span>
<span id="2346">2346</span>
<span id="2347">2347</span>
<span id="2348">2348</span>
<span id="2349">2349</span>
<span id="2350">2350</span>
<span id="2351">2351</span>
<span id="2352">2352</span>
<span id="2353">2353</span>
<span id="2354">2354</span>
<span id="2355">2355</span>
<span id="2356">2356</span>
<span id="2357">2357</span>
<span id="2358">2358</span>
<span id="2359">2359</span>
<span id="2360">2360</span>
<span id="2361">2361</span>
<span id="2362">2362</span>
<span id="2363">2363</span>
<span id="2364">2364</span>
<span id="2365">2365</span>
<span id="2366">2366</span>
<span id="2367">2367</span>
<span id="2368">2368</span>
<span id="2369">2369</span>
<span id="2370">2370</span>
<span id="2371">2371</span>
<span id="2372">2372</span>
<span id="2373">2373</span>
<span id="2374">2374</span>
<span id="2375">2375</span>
<span id="2376">2376</span>
<span id="2377">2377</span>
<span id="2378">2378</span>
<span id="2379">2379</span>
<span id="2380">2380</span>
<span id="2381">2381</span>
<span id="2382">2382</span>
<span id="2383">2383</span>
<span id="2384">2384</span>
<span id="2385">2385</span>
<span id="2386">2386</span>
<span id="2387">2387</span>
<span id="2388">2388</span>
<span id="2389">2389</span>
<span id="2390">2390</span>
<span id="2391">2391</span>
<span id="2392">2392</span>
<span id="2393">2393</span>
<span id="2394">2394</span>
<span id="2395">2395</span>
<span id="2396">2396</span>
<span id="2397">2397</span>
<span id="2398">2398</span>
<span id="2399">2399</span>
<span id="2400">2400</span>
<span id="2401">2401</span>
<span id="2402">2402</span>
<span id="2403">2403</span>
<span id="2404">2404</span>
<span id="2405">2405</span>
<span id="2406">2406</span>
<span id="2407">2407</span>
<span id="2408">2408</span>
<span id="2409">2409</span>
<span id="2410">2410</span>
<span id="2411">2411</span>
<span id="2412">2412</span>
<span id="2413">2413</span>
<span id="2414">2414</span>
<span id="2415">2415</span>
<span id="2416">2416</span>
<span id="2417">2417</span>
<span id="2418">2418</span>
<span id="2419">2419</span>
<span id="2420">2420</span>
<span id="2421">2421</span>
<span id="2422">2422</span>
<span id="2423">2423</span>
<span id="2424">2424</span>
<span id="2425">2425</span>
<span id="2426">2426</span>
<span id="2427">2427</span>
<span id="2428">2428</span>
<span id="2429">2429</span>
<span id="2430">2430</span>
<span id="2431">2431</span>
<span id="2432">2432</span>
<span id="2433">2433</span>
<span id="2434">2434</span>
<span id="2435">2435</span>
<span id="2436">2436</span>
<span id="2437">2437</span>
<span id="2438">2438</span>
<span id="2439">2439</span>
<span id="2440">2440</span>
<span id="2441">2441</span>
<span id="2442">2442</span>
<span id="2443">2443</span>
<span id="2444">2444</span>
<span id="2445">2445</span>
<span id="2446">2446</span>
<span id="2447">2447</span>
<span id="2448">2448</span>
<span id="2449">2449</span>
<span id="2450">2450</span>
<span id="2451">2451</span>
<span id="2452">2452</span>
<span id="2453">2453</span>
<span id="2454">2454</span>
<span id="2455">2455</span>
<span id="2456">2456</span>
<span id="2457">2457</span>
<span id="2458">2458</span>
<span id="2459">2459</span>
<span id="2460">2460</span>
<span id="2461">2461</span>
<span id="2462">2462</span>
<span id="2463">2463</span>
<span id="2464">2464</span>
<span id="2465">2465</span>
<span id="2466">2466</span>
<span id="2467">2467</span>
<span id="2468">2468</span>
<span id="2469">2469</span>
<span id="2470">2470</span>
<span id="2471">2471</span>
<span id="2472">2472</span>
<span id="2473">2473</span>
<span id="2474">2474</span>
<span id="2475">2475</span>
<span id="2476">2476</span>
<span id="2477">2477</span>
<span id="2478">2478</span>
<span id="2479">2479</span>
<span id="2480">2480</span>
<span id="2481">2481</span>
<span id="2482">2482</span>
<span id="2483">2483</span>
<span id="2484">2484</span>
<span id="2485">2485</span>
<span id="2486">2486</span>
<span id="2487">2487</span>
<span id="2488">2488</span>
<span id="2489">2489</span>
<span id="2490">2490</span>
<span id="2491">2491</span>
<span id="2492">2492</span>
<span id="2493">2493</span>
<span id="2494">2494</span>
<span id="2495">2495</span>
<span id="2496">2496</span>
<span id="2497">2497</span>
<span id="2498">2498</span>
<span id="2499">2499</span>
<span id="2500">2500</span>
<span id="2501">2501</span>
<span id="2502">2502</span>
<span id="2503">2503</span>
<span id="2504">2504</span>
<span id="2505">2505</span>
<span id="2506">2506</span>
<span id="2507">2507</span>
<span id="2508">2508</span>
<span id="2509">2509</span>
<span id="2510">2510</span>
<span id="2511">2511</span>
<span id="2512">2512</span>
<span id="2513">2513</span>
<span id="2514">2514</span>
<span id="2515">2515</span>
<span id="2516">2516</span>
<span id="2517">2517</span>
<span id="2518">2518</span>
<span id="2519">2519</span>
<span id="2520">2520</span>
<span id="2521">2521</span>
<span id="2522">2522</span>
<span id="2523">2523</span>
<span id="2524">2524</span>
<span id="2525">2525</span>
<span id="2526">2526</span>
<span id="2527">2527</span>
<span id="2528">2528</span>
<span id="2529">2529</span>
<span id="2530">2530</span>
<span id="2531">2531</span>
<span id="2532">2532</span>
<span id="2533">2533</span>
<span id="2534">2534</span>
<span id="2535">2535</span>
<span id="2536">2536</span>
<span id="2537">2537</span>
<span id="2538">2538</span>
<span id="2539">2539</span>
<span id="2540">2540</span>
<span id="2541">2541</span>
<span id="2542">2542</span>
<span id="2543">2543</span>
<span id="2544">2544</span>
<span id="2545">2545</span>
<span id="2546">2546</span>
<span id="2547">2547</span>
<span id="2548">2548</span>
<span id="2549">2549</span>
<span id="2550">2550</span>
<span id="2551">2551</span>
<span id="2552">2552</span>
<span id="2553">2553</span>
<span id="2554">2554</span>
<span id="2555">2555</span>
<span id="2556">2556</span>
<span id="2557">2557</span>
<span id="2558">2558</span>
<span id="2559">2559</span>
<span id="2560">2560</span>
<span id="2561">2561</span>
<span id="2562">2562</span>
<span id="2563">2563</span>
<span id="2564">2564</span>
<span id="2565">2565</span>
<span id="2566">2566</span>
<span id="2567">2567</span>
<span id="2568">2568</span>
<span id="2569">2569</span>
<span id="2570">2570</span>
<span id="2571">2571</span>
<span id="2572">2572</span>
<span id="2573">2573</span>
<span id="2574">2574</span>
<span id="2575">2575</span>
<span id="2576">2576</span>
<span id="2577">2577</span>
<span id="2578">2578</span>
<span id="2579">2579</span>
<span id="2580">2580</span>
<span id="2581">2581</span>
<span id="2582">2582</span>
<span id="2583">2583</span>
<span id="2584">2584</span>
<span id="2585">2585</span>
<span id="2586">2586</span>
<span id="2587">2587</span>
<span id="2588">2588</span>
<span id="2589">2589</span>
<span id="2590">2590</span>
<span id="2591">2591</span>
<span id="2592">2592</span>
<span id="2593">2593</span>
<span id="2594">2594</span>
<span id="2595">2595</span>
<span id="2596">2596</span>
<span id="2597">2597</span>
<span id="2598">2598</span>
<span id="2599">2599</span>
<span id="2600">2600</span>
<span id="2601">2601</span>
<span id="2602">2602</span>
<span id="2603">2603</span>
<span id="2604">2604</span>
<span id="2605">2605</span>
<span id="2606">2606</span>
<span id="2607">2607</span>
<span id="2608">2608</span>
<span id="2609">2609</span>
<span id="2610">2610</span>
<span id="2611">2611</span>
<span id="2612">2612</span>
<span id="2613">2613</span>
<span id="2614">2614</span>
<span id="2615">2615</span>
<span id="2616">2616</span>
<span id="2617">2617</span>
<span id="2618">2618</span>
<span id="2619">2619</span>
<span id="2620">2620</span>
<span id="2621">2621</span>
<span id="2622">2622</span>
<span id="2623">2623</span>
<span id="2624">2624</span>
<span id="2625">2625</span>
<span id="2626">2626</span>
<span id="2627">2627</span>
<span id="2628">2628</span>
<span id="2629">2629</span>
<span id="2630">2630</span>
<span id="2631">2631</span>
<span id="2632">2632</span>
<span id="2633">2633</span>
<span id="2634">2634</span>
<span id="2635">2635</span>
<span id="2636">2636</span>
<span id="2637">2637</span>
<span id="2638">2638</span>
<span id="2639">2639</span>
<span id="2640">2640</span>
<span id="2641">2641</span>
<span id="2642">2642</span>
<span id="2643">2643</span>
<span id="2644">2644</span>
<span id="2645">2645</span>
<span id="2646">2646</span>
<span id="2647">2647</span>
<span id="2648">2648</span>
<span id="2649">2649</span>
<span id="2650">2650</span>
<span id="2651">2651</span>
<span id="2652">2652</span>
<span id="2653">2653</span>
<span id="2654">2654</span>
<span id="2655">2655</span>
<span id="2656">2656</span>
<span id="2657">2657</span>
<span id="2658">2658</span>
<span id="2659">2659</span>
<span id="2660">2660</span>
<span id="2661">2661</span>
<span id="2662">2662</span>
<span id="2663">2663</span>
<span id="2664">2664</span>
<span id="2665">2665</span>
<span id="2666">2666</span>
<span id="2667">2667</span>
<span id="2668">2668</span>
<span id="2669">2669</span>
<span id="2670">2670</span>
<span id="2671">2671</span>
<span id="2672">2672</span>
<span id="2673">2673</span>
<span id="2674">2674</span>
<span id="2675">2675</span>
<span id="2676">2676</span>
<span id="2677">2677</span>
<span id="2678">2678</span>
<span id="2679">2679</span>
<span id="2680">2680</span>
<span id="2681">2681</span>
<span id="2682">2682</span>
<span id="2683">2683</span>
<span id="2684">2684</span>
<span id="2685">2685</span>
<span id="2686">2686</span>
<span id="2687">2687</span>
<span id="2688">2688</span>
<span id="2689">2689</span>
<span id="2690">2690</span>
<span id="2691">2691</span>
<span id="2692">2692</span>
<span id="2693">2693</span>
<span id="2694">2694</span>
<span id="2695">2695</span>
<span id="2696">2696</span>
<span id="2697">2697</span>
<span id="2698">2698</span>
<span id="2699">2699</span>
<span id="2700">2700</span>
<span id="2701">2701</span>
<span id="2702">2702</span>
<span id="2703">2703</span>
<span id="2704">2704</span>
<span id="2705">2705</span>
<span id="2706">2706</span>
<span id="2707">2707</span>
<span id="2708">2708</span>
<span id="2709">2709</span>
<span id="2710">2710</span>
<span id="2711">2711</span>
<span id="2712">2712</span>
<span id="2713">2713</span>
<span id="2714">2714</span>
<span id="2715">2715</span>
<span id="2716">2716</span>
<span id="2717">2717</span>
<span id="2718">2718</span>
<span id="2719">2719</span>
<span id="2720">2720</span>
<span id="2721">2721</span>
<span id="2722">2722</span>
<span id="2723">2723</span>
<span id="2724">2724</span>
<span id="2725">2725</span>
<span id="2726">2726</span>
<span id="2727">2727</span>
<span id="2728">2728</span>
<span id="2729">2729</span>
<span id="2730">2730</span>
<span id="2731">2731</span>
<span id="2732">2732</span>
<span id="2733">2733</span>
<span id="2734">2734</span>
<span id="2735">2735</span>
<span id="2736">2736</span>
<span id="2737">2737</span>
<span id="2738">2738</span>
<span id="2739">2739</span>
<span id="2740">2740</span>
<span id="2741">2741</span>
<span id="2742">2742</span>
<span id="2743">2743</span>
<span id="2744">2744</span>
<span id="2745">2745</span>
<span id="2746">2746</span>
<span id="2747">2747</span>
<span id="2748">2748</span>
<span id="2749">2749</span>
<span id="2750">2750</span>
<span id="2751">2751</span>
<span id="2752">2752</span>
<span id="2753">2753</span>
<span id="2754">2754</span>
<span id="2755">2755</span>
<span id="2756">2756</span>
<span id="2757">2757</span>
<span id="2758">2758</span>
<span id="2759">2759</span>
<span id="2760">2760</span>
<span id="2761">2761</span>
<span id="2762">2762</span>
<span id="2763">2763</span>
<span id="2764">2764</span>
<span id="2765">2765</span>
<span id="2766">2766</span>
<span id="2767">2767</span>
<span id="2768">2768</span>
<span id="2769">2769</span>
<span id="2770">2770</span>
<span id="2771">2771</span>
<span id="2772">2772</span>
<span id="2773">2773</span>
<span id="2774">2774</span>
<span id="2775">2775</span>
<span id="2776">2776</span>
<span id="2777">2777</span>
<span id="2778">2778</span>
<span id="2779">2779</span>
<span id="2780">2780</span>
<span id="2781">2781</span>
<span id="2782">2782</span>
<span id="2783">2783</span>
<span id="2784">2784</span>
<span id="2785">2785</span>
<span id="2786">2786</span>
<span id="2787">2787</span>
<span id="2788">2788</span>
<span id="2789">2789</span>
<span id="2790">2790</span>
<span id="2791">2791</span>
<span id="2792">2792</span>
<span id="2793">2793</span>
<span id="2794">2794</span>
<span id="2795">2795</span>
<span id="2796">2796</span>
<span id="2797">2797</span>
<span id="2798">2798</span>
<span id="2799">2799</span>
<span id="2800">2800</span>
<span id="2801">2801</span>
<span id="2802">2802</span>
<span id="2803">2803</span>
<span id="2804">2804</span>
<span id="2805">2805</span>
<span id="2806">2806</span>
<span id="2807">2807</span>
<span id="2808">2808</span>
<span id="2809">2809</span>
<span id="2810">2810</span>
<span id="2811">2811</span>
<span id="2812">2812</span>
<span id="2813">2813</span>
<span id="2814">2814</span>
<span id="2815">2815</span>
<span id="2816">2816</span>
<span id="2817">2817</span>
<span id="2818">2818</span>
<span id="2819">2819</span>
<span id="2820">2820</span>
<span id="2821">2821</span>
<span id="2822">2822</span>
<span id="2823">2823</span>
<span id="2824">2824</span>
<span id="2825">2825</span>
<span id="2826">2826</span>
<span id="2827">2827</span>
<span id="2828">2828</span>
<span id="2829">2829</span>
<span id="2830">2830</span>
<span id="2831">2831</span>
<span id="2832">2832</span>
<span id="2833">2833</span>
<span id="2834">2834</span>
<span id="2835">2835</span>
<span id="2836">2836</span>
<span id="2837">2837</span>
<span id="2838">2838</span>
<span id="2839">2839</span>
<span id="2840">2840</span>
<span id="2841">2841</span>
<span id="2842">2842</span>
<span id="2843">2843</span>
<span id="2844">2844</span>
<span id="2845">2845</span>
<span id="2846">2846</span>
<span id="2847">2847</span>
<span id="2848">2848</span>
<span id="2849">2849</span>
<span id="2850">2850</span>
<span id="2851">2851</span>
<span id="2852">2852</span>
<span id="2853">2853</span>
<span id="2854">2854</span>
<span id="2855">2855</span>
<span id="2856">2856</span>
<span id="2857">2857</span>
<span id="2858">2858</span>
<span id="2859">2859</span>
<span id="2860">2860</span>
<span id="2861">2861</span>
<span id="2862">2862</span>
<span id="2863">2863</span>
<span id="2864">2864</span>
<span id="2865">2865</span>
<span id="2866">2866</span>
<span id="2867">2867</span>
<span id="2868">2868</span>
<span id="2869">2869</span>
<span id="2870">2870</span>
<span id="2871">2871</span>
<span id="2872">2872</span>
<span id="2873">2873</span>
<span id="2874">2874</span>
<span id="2875">2875</span>
<span id="2876">2876</span>
<span id="2877">2877</span>
<span id="2878">2878</span>
<span id="2879">2879</span>
<span id="2880">2880</span>
<span id="2881">2881</span>
<span id="2882">2882</span>
<span id="2883">2883</span>
<span id="2884">2884</span>
<span id="2885">2885</span>
<span id="2886">2886</span>
<span id="2887">2887</span>
<span id="2888">2888</span>
<span id="2889">2889</span>
<span id="2890">2890</span>
<span id="2891">2891</span>
<span id="2892">2892</span>
<span id="2893">2893</span>
<span id="2894">2894</span>
<span id="2895">2895</span>
<span id="2896">2896</span>
<span id="2897">2897</span>
<span id="2898">2898</span>
<span id="2899">2899</span>
<span id="2900">2900</span>
<span id="2901">2901</span>
<span id="2902">2902</span>
<span id="2903">2903</span>
<span id="2904">2904</span>
<span id="2905">2905</span>
<span id="2906">2906</span>
<span id="2907">2907</span>
<span id="2908">2908</span>
<span id="2909">2909</span>
<span id="2910">2910</span>
<span id="2911">2911</span>
<span id="2912">2912</span>
<span id="2913">2913</span>
<span id="2914">2914</span>
<span id="2915">2915</span>
<span id="2916">2916</span>
<span id="2917">2917</span>
<span id="2918">2918</span>
<span id="2919">2919</span>
<span id="2920">2920</span>
<span id="2921">2921</span>
<span id="2922">2922</span>
<span id="2923">2923</span>
<span id="2924">2924</span>
<span id="2925">2925</span>
<span id="2926">2926</span>
<span id="2927">2927</span>
<span id="2928">2928</span>
<span id="2929">2929</span>
<span id="2930">2930</span>
<span id="2931">2931</span>
<span id="2932">2932</span>
<span id="2933">2933</span>
<span id="2934">2934</span>
<span id="2935">2935</span>
<span id="2936">2936</span>
<span id="2937">2937</span>
<span id="2938">2938</span>
<span id="2939">2939</span>
<span id="2940">2940</span>
<span id="2941">2941</span>
<span id="2942">2942</span>
<span id="2943">2943</span>
<span id="2944">2944</span>
<span id="2945">2945</span>
<span id="2946">2946</span>
<span id="2947">2947</span>
<span id="2948">2948</span>
<span id="2949">2949</span>
<span id="2950">2950</span>
<span id="2951">2951</span>
<span id="2952">2952</span>
<span id="2953">2953</span>
<span id="2954">2954</span>
<span id="2955">2955</span>
<span id="2956">2956</span>
<span id="2957">2957</span>
<span id="2958">2958</span>
<span id="2959">2959</span>
<span id="2960">2960</span>
<span id="2961">2961</span>
<span id="2962">2962</span>
<span id="2963">2963</span>
<span id="2964">2964</span>
<span id="2965">2965</span>
<span id="2966">2966</span>
<span id="2967">2967</span>
<span id="2968">2968</span>
<span id="2969">2969</span>
<span id="2970">2970</span>
<span id="2971">2971</span>
<span id="2972">2972</span>
<span id="2973">2973</span>
<span id="2974">2974</span>
<span id="2975">2975</span>
<span id="2976">2976</span>
<span id="2977">2977</span>
<span id="2978">2978</span>
<span id="2979">2979</span>
<span id="2980">2980</span>
<span id="2981">2981</span>
<span id="2982">2982</span>
<span id="2983">2983</span>
<span id="2984">2984</span>
<span id="2985">2985</span>
<span id="2986">2986</span>
<span id="2987">2987</span>
<span id="2988">2988</span>
<span id="2989">2989</span>
<span id="2990">2990</span>
<span id="2991">2991</span>
<span id="2992">2992</span>
<span id="2993">2993</span>
<span id="2994">2994</span>
<span id="2995">2995</span>
<span id="2996">2996</span>
<span id="2997">2997</span>
<span id="2998">2998</span>
<span id="2999">2999</span>
<span id="3000">3000</span>
<span id="3001">3001</span>
<span id="3002">3002</span>
<span id="3003">3003</span>
<span id="3004">3004</span>
<span id="3005">3005</span>
<span id="3006">3006</span>
<span id="3007">3007</span>
<span id="3008">3008</span>
<span id="3009">3009</span>
<span id="3010">3010</span>
<span id="3011">3011</span>
<span id="3012">3012</span>
<span id="3013">3013</span>
<span id="3014">3014</span>
<span id="3015">3015</span>
<span id="3016">3016</span>
<span id="3017">3017</span>
<span id="3018">3018</span>
<span id="3019">3019</span>
<span id="3020">3020</span>
<span id="3021">3021</span>
<span id="3022">3022</span>
<span id="3023">3023</span>
<span id="3024">3024</span>
<span id="3025">3025</span>
<span id="3026">3026</span>
<span id="3027">3027</span>
<span id="3028">3028</span>
<span id="3029">3029</span>
<span id="3030">3030</span>
<span id="3031">3031</span>
<span id="3032">3032</span>
<span id="3033">3033</span>
<span id="3034">3034</span>
<span id="3035">3035</span>
<span id="3036">3036</span>
<span id="3037">3037</span>
<span id="3038">3038</span>
<span id="3039">3039</span>
<span id="3040">3040</span>
<span id="3041">3041</span>
<span id="3042">3042</span>
<span id="3043">3043</span>
<span id="3044">3044</span>
<span id="3045">3045</span>
<span id="3046">3046</span>
<span id="3047">3047</span>
<span id="3048">3048</span>
<span id="3049">3049</span>
<span id="3050">3050</span>
<span id="3051">3051</span>
<span id="3052">3052</span>
<span id="3053">3053</span>
<span id="3054">3054</span>
<span id="3055">3055</span>
<span id="3056">3056</span>
<span id="3057">3057</span>
<span id="3058">3058</span>
<span id="3059">3059</span>
<span id="3060">3060</span>
<span id="3061">3061</span>
<span id="3062">3062</span>
<span id="3063">3063</span>
<span id="3064">3064</span>
<span id="3065">3065</span>
<span id="3066">3066</span>
<span id="3067">3067</span>
<span id="3068">3068</span>
<span id="3069">3069</span>
<span id="3070">3070</span>
<span id="3071">3071</span>
<span id="3072">3072</span>
<span id="3073">3073</span>
<span id="3074">3074</span>
<span id="3075">3075</span>
<span id="3076">3076</span>
<span id="3077">3077</span>
<span id="3078">3078</span>
<span id="3079">3079</span>
<span id="3080">3080</span>
<span id="3081">3081</span>
<span id="3082">3082</span>
<span id="3083">3083</span>
<span id="3084">3084</span>
<span id="3085">3085</span>
<span id="3086">3086</span>
<span id="3087">3087</span>
<span id="3088">3088</span>
<span id="3089">3089</span>
<span id="3090">3090</span>
<span id="3091">3091</span>
<span id="3092">3092</span>
<span id="3093">3093</span>
<span id="3094">3094</span>
<span id="3095">3095</span>
<span id="3096">3096</span>
<span id="3097">3097</span>
<span id="3098">3098</span>
<span id="3099">3099</span>
<span id="3100">3100</span>
<span id="3101">3101</span>
<span id="3102">3102</span>
<span id="3103">3103</span>
<span id="3104">3104</span>
<span id="3105">3105</span>
<span id="3106">3106</span>
<span id="3107">3107</span>
<span id="3108">3108</span>
<span id="3109">3109</span>
<span id="3110">3110</span>
<span id="3111">3111</span>
<span id="3112">3112</span>
<span id="3113">3113</span>
<span id="3114">3114</span>
<span id="3115">3115</span>
<span id="3116">3116</span>
<span id="3117">3117</span>
<span id="3118">3118</span>
<span id="3119">3119</span>
<span id="3120">3120</span>
<span id="3121">3121</span>
<span id="3122">3122</span>
<span id="3123">3123</span>
<span id="3124">3124</span>
<span id="3125">3125</span>
<span id="3126">3126</span>
<span id="3127">3127</span>
<span id="3128">3128</span>
<span id="3129">3129</span>
<span id="3130">3130</span>
<span id="3131">3131</span>
<span id="3132">3132</span>
<span id="3133">3133</span>
<span id="3134">3134</span>
<span id="3135">3135</span>
<span id="3136">3136</span>
<span id="3137">3137</span>
<span id="3138">3138</span>
<span id="3139">3139</span>
<span id="3140">3140</span>
<span id="3141">3141</span>
<span id="3142">3142</span>
<span id="3143">3143</span>
<span id="3144">3144</span>
<span id="3145">3145</span>
<span id="3146">3146</span>
<span id="3147">3147</span>
<span id="3148">3148</span>
<span id="3149">3149</span>
<span id="3150">3150</span>
<span id="3151">3151</span>
<span id="3152">3152</span>
<span id="3153">3153</span>
<span id="3154">3154</span>
<span id="3155">3155</span>
<span id="3156">3156</span>
<span id="3157">3157</span>
<span id="3158">3158</span>
<span id="3159">3159</span>
<span id="3160">3160</span>
<span id="3161">3161</span>
<span id="3162">3162</span>
<span id="3163">3163</span>
<span id="3164">3164</span>
<span id="3165">3165</span>
<span id="3166">3166</span>
<span id="3167">3167</span>
<span id="3168">3168</span>
<span id="3169">3169</span>
<span id="3170">3170</span>
<span id="3171">3171</span>
<span id="3172">3172</span>
<span id="3173">3173</span>
<span id="3174">3174</span>
<span id="3175">3175</span>
<span id="3176">3176</span>
<span id="3177">3177</span>
<span id="3178">3178</span>
<span id="3179">3179</span>
<span id="3180">3180</span>
<span id="3181">3181</span>
<span id="3182">3182</span>
<span id="3183">3183</span>
<span id="3184">3184</span>
<span id="3185">3185</span>
<span id="3186">3186</span>
<span id="3187">3187</span>
<span id="3188">3188</span>
<span id="3189">3189</span>
<span id="3190">3190</span>
<span id="3191">3191</span>
<span id="3192">3192</span>
<span id="3193">3193</span>
<span id="3194">3194</span>
<span id="3195">3195</span>
<span id="3196">3196</span>
<span id="3197">3197</span>
<span id="3198">3198</span>
<span id="3199">3199</span>
<span id="3200">3200</span>
<span id="3201">3201</span>
<span id="3202">3202</span>
<span id="3203">3203</span>
<span id="3204">3204</span>
<span id="3205">3205</span>
<span id="3206">3206</span>
<span id="3207">3207</span>
<span id="3208">3208</span>
<span id="3209">3209</span>
<span id="3210">3210</span>
<span id="3211">3211</span>
<span id="3212">3212</span>
<span id="3213">3213</span>
<span id="3214">3214</span>
<span id="3215">3215</span>
<span id="3216">3216</span>
<span id="3217">3217</span>
<span id="3218">3218</span>
<span id="3219">3219</span>
<span id="3220">3220</span>
<span id="3221">3221</span>
<span id="3222">3222</span>
<span id="3223">3223</span>
<span id="3224">3224</span>
<span id="3225">3225</span>
<span id="3226">3226</span>
<span id="3227">3227</span>
<span id="3228">3228</span>
<span id="3229">3229</span>
<span id="3230">3230</span>
<span id="3231">3231</span>
<span id="3232">3232</span>
<span id="3233">3233</span>
<span id="3234">3234</span>
<span id="3235">3235</span>
<span id="3236">3236</span>
<span id="3237">3237</span>
<span id="3238">3238</span>
<span id="3239">3239</span>
<span id="3240">3240</span>
<span id="3241">3241</span>
<span id="3242">3242</span>
<span id="3243">3243</span>
<span id="3244">3244</span>
<span id="3245">3245</span>
<span id="3246">3246</span>
<span id="3247">3247</span>
<span id="3248">3248</span>
<span id="3249">3249</span>
<span id="3250">3250</span>
<span id="3251">3251</span>
<span id="3252">3252</span>
<span id="3253">3253</span>
<span id="3254">3254</span>
<span id="3255">3255</span>
<span id="3256">3256</span>
<span id="3257">3257</span>
<span id="3258">3258</span>
<span id="3259">3259</span>
<span id="3260">3260</span>
<span id="3261">3261</span>
<span id="3262">3262</span>
<span id="3263">3263</span>
<span id="3264">3264</span>
<span id="3265">3265</span>
<span id="3266">3266</span>
<span id="3267">3267</span>
<span id="3268">3268</span>
<span id="3269">3269</span>
<span id="3270">3270</span>
<span id="3271">3271</span>
<span id="3272">3272</span>
<span id="3273">3273</span>
<span id="3274">3274</span>
<span id="3275">3275</span>
<span id="3276">3276</span>
<span id="3277">3277</span>
<span id="3278">3278</span>
<span id="3279">3279</span>
<span id="3280">3280</span>
<span id="3281">3281</span>
<span id="3282">3282</span>
<span id="3283">3283</span>
<span id="3284">3284</span>
<span id="3285">3285</span>
<span id="3286">3286</span>
<span id="3287">3287</span>
<span id="3288">3288</span>
<span id="3289">3289</span>
<span id="3290">3290</span>
<span id="3291">3291</span>
<span id="3292">3292</span>
<span id="3293">3293</span>
<span id="3294">3294</span>
<span id="3295">3295</span>
<span id="3296">3296</span>
<span id="3297">3297</span>
<span id="3298">3298</span>
<span id="3299">3299</span>
<span id="3300">3300</span>
<span id="3301">3301</span>
<span id="3302">3302</span>
<span id="3303">3303</span>
<span id="3304">3304</span>
<span id="3305">3305</span>
<span id="3306">3306</span>
<span id="3307">3307</span>
<span id="3308">3308</span>
<span id="3309">3309</span>
<span id="3310">3310</span>
<span id="3311">3311</span>
<span id="3312">3312</span>
<span id="3313">3313</span>
<span id="3314">3314</span>
<span id="3315">3315</span>
<span id="3316">3316</span>
<span id="3317">3317</span>
<span id="3318">3318</span>
<span id="3319">3319</span>
<span id="3320">3320</span>
<span id="3321">3321</span>
<span id="3322">3322</span>
<span id="3323">3323</span>
<span id="3324">3324</span>
<span id="3325">3325</span>
<span id="3326">3326</span>
<span id="3327">3327</span>
<span id="3328">3328</span>
<span id="3329">3329</span>
<span id="3330">3330</span>
<span id="3331">3331</span>
<span id="3332">3332</span>
<span id="3333">3333</span>
<span id="3334">3334</span>
<span id="3335">3335</span>
<span id="3336">3336</span>
<span id="3337">3337</span>
<span id="3338">3338</span>
<span id="3339">3339</span>
<span id="3340">3340</span>
<span id="3341">3341</span>
<span id="3342">3342</span>
<span id="3343">3343</span>
<span id="3344">3344</span>
<span id="3345">3345</span>
<span id="3346">3346</span>
<span id="3347">3347</span>
<span id="3348">3348</span>
<span id="3349">3349</span>
<span id="3350">3350</span>
<span id="3351">3351</span>
<span id="3352">3352</span>
<span id="3353">3353</span>
<span id="3354">3354</span>
<span id="3355">3355</span>
<span id="3356">3356</span>
<span id="3357">3357</span>
<span id="3358">3358</span>
<span id="3359">3359</span>
<span id="3360">3360</span>
<span id="3361">3361</span>
<span id="3362">3362</span>
<span id="3363">3363</span>
<span id="3364">3364</span>
<span id="3365">3365</span>
<span id="3366">3366</span>
<span id="3367">3367</span>
<span id="3368">3368</span>
<span id="3369">3369</span>
<span id="3370">3370</span>
<span id="3371">3371</span>
<span id="3372">3372</span>
<span id="3373">3373</span>
<span id="3374">3374</span>
<span id="3375">3375</span>
<span id="3376">3376</span>
<span id="3377">3377</span>
<span id="3378">3378</span>
<span id="3379">3379</span>
<span id="3380">3380</span>
<span id="3381">3381</span>
<span id="3382">3382</span>
<span id="3383">3383</span>
<span id="3384">3384</span>
<span id="3385">3385</span>
<span id="3386">3386</span>
<span id="3387">3387</span>
<span id="3388">3388</span>
<span id="3389">3389</span>
<span id="3390">3390</span>
<span id="3391">3391</span>
<span id="3392">3392</span>
<span id="3393">3393</span>
<span id="3394">3394</span>
<span id="3395">3395</span>
<span id="3396">3396</span>
<span id="3397">3397</span>
<span id="3398">3398</span>
<span id="3399">3399</span>
<span id="3400">3400</span>
<span id="3401">3401</span>
<span id="3402">3402</span>
<span id="3403">3403</span>
<span id="3404">3404</span>
<span id="3405">3405</span>
<span id="3406">3406</span>
<span id="3407">3407</span>
<span id="3408">3408</span>
<span id="3409">3409</span>
<span id="3410">3410</span>
<span id="3411">3411</span>
<span id="3412">3412</span>
<span id="3413">3413</span>
<span id="3414">3414</span>
<span id="3415">3415</span>
<span id="3416">3416</span>
<span id="3417">3417</span>
<span id="3418">3418</span>
<span id="3419">3419</span>
<span id="3420">3420</span>
<span id="3421">3421</span>
<span id="3422">3422</span>
<span id="3423">3423</span>
<span id="3424">3424</span>
<span id="3425">3425</span>
<span id="3426">3426</span>
<span id="3427">3427</span>
<span id="3428">3428</span>
<span id="3429">3429</span>
<span id="3430">3430</span>
<span id="3431">3431</span>
<span id="3432">3432</span>
<span id="3433">3433</span>
<span id="3434">3434</span>
<span id="3435">3435</span>
<span id="3436">3436</span>
<span id="3437">3437</span>
<span id="3438">3438</span>
<span id="3439">3439</span>
<span id="3440">3440</span>
<span id="3441">3441</span>
<span id="3442">3442</span>
<span id="3443">3443</span>
<span id="3444">3444</span>
<span id="3445">3445</span>
<span id="3446">3446</span>
<span id="3447">3447</span>
<span id="3448">3448</span>
<span id="3449">3449</span>
<span id="3450">3450</span>
<span id="3451">3451</span>
<span id="3452">3452</span>
<span id="3453">3453</span>
<span id="3454">3454</span>
<span id="3455">3455</span>
<span id="3456">3456</span>
<span id="3457">3457</span>
<span id="3458">3458</span>
<span id="3459">3459</span>
<span id="3460">3460</span>
<span id="3461">3461</span>
<span id="3462">3462</span>
<span id="3463">3463</span>
<span id="3464">3464</span>
<span id="3465">3465</span>
<span id="3466">3466</span>
<span id="3467">3467</span>
<span id="3468">3468</span>
<span id="3469">3469</span>
<span id="3470">3470</span>
<span id="3471">3471</span>
<span id="3472">3472</span>
<span id="3473">3473</span>
<span id="3474">3474</span>
<span id="3475">3475</span>
<span id="3476">3476</span>
<span id="3477">3477</span>
<span id="3478">3478</span>
<span id="3479">3479</span>
<span id="3480">3480</span>
<span id="3481">3481</span>
<span id="3482">3482</span>
<span id="3483">3483</span>
<span id="3484">3484</span>
<span id="3485">3485</span>
<span id="3486">3486</span>
<span id="3487">3487</span>
<span id="3488">3488</span>
<span id="3489">3489</span>
<span id="3490">3490</span>
<span id="3491">3491</span>
<span id="3492">3492</span>
<span id="3493">3493</span>
<span id="3494">3494</span>
<span id="3495">3495</span>
<span id="3496">3496</span>
<span id="3497">3497</span>
<span id="3498">3498</span>
<span id="3499">3499</span>
<span id="3500">3500</span>
<span id="3501">3501</span>
<span id="3502">3502</span>
<span id="3503">3503</span>
<span id="3504">3504</span>
<span id="3505">3505</span>
<span id="3506">3506</span>
<span id="3507">3507</span>
<span id="3508">3508</span>
<span id="3509">3509</span>
<span id="3510">3510</span>
<span id="3511">3511</span>
<span id="3512">3512</span>
<span id="3513">3513</span>
<span id="3514">3514</span>
<span id="3515">3515</span>
<span id="3516">3516</span>
<span id="3517">3517</span>
<span id="3518">3518</span>
<span id="3519">3519</span>
<span id="3520">3520</span>
<span id="3521">3521</span>
<span id="3522">3522</span>
<span id="3523">3523</span>
<span id="3524">3524</span>
<span id="3525">3525</span>
<span id="3526">3526</span>
<span id="3527">3527</span>
<span id="3528">3528</span>
<span id="3529">3529</span>
<span id="3530">3530</span>
<span id="3531">3531</span>
<span id="3532">3532</span>
<span id="3533">3533</span>
<span id="3534">3534</span>
<span id="3535">3535</span>
<span id="3536">3536</span>
<span id="3537">3537</span>
<span id="3538">3538</span>
<span id="3539">3539</span>
<span id="3540">3540</span>
<span id="3541">3541</span>
<span id="3542">3542</span>
<span id="3543">3543</span>
<span id="3544">3544</span>
<span id="3545">3545</span>
<span id="3546">3546</span>
<span id="3547">3547</span>
<span id="3548">3548</span>
<span id="3549">3549</span>
<span id="3550">3550</span>
<span id="3551">3551</span>
<span id="3552">3552</span>
<span id="3553">3553</span>
<span id="3554">3554</span>
<span id="3555">3555</span>
<span id="3556">3556</span>
<span id="3557">3557</span>
<span id="3558">3558</span>
<span id="3559">3559</span>
<span id="3560">3560</span>
<span id="3561">3561</span>
<span id="3562">3562</span>
<span id="3563">3563</span>
<span id="3564">3564</span>
<span id="3565">3565</span>
<span id="3566">3566</span>
<span id="3567">3567</span>
<span id="3568">3568</span>
<span id="3569">3569</span>
<span id="3570">3570</span>
<span id="3571">3571</span>
<span id="3572">3572</span>
<span id="3573">3573</span>
<span id="3574">3574</span>
<span id="3575">3575</span>
<span id="3576">3576</span>
<span id="3577">3577</span>
<span id="3578">3578</span>
<span id="3579">3579</span>
<span id="3580">3580</span>
<span id="3581">3581</span>
<span id="3582">3582</span>
<span id="3583">3583</span>
<span id="3584">3584</span>
<span id="3585">3585</span>
<span id="3586">3586</span>
<span id="3587">3587</span>
<span id="3588">3588</span>
<span id="3589">3589</span>
<span id="3590">3590</span>
<span id="3591">3591</span>
<span id="3592">3592</span>
<span id="3593">3593</span>
<span id="3594">3594</span>
<span id="3595">3595</span>
<span id="3596">3596</span>
<span id="3597">3597</span>
<span id="3598">3598</span>
<span id="3599">3599</span>
<span id="3600">3600</span>
<span id="3601">3601</span>
<span id="3602">3602</span>
<span id="3603">3603</span>
<span id="3604">3604</span>
<span id="3605">3605</span>
<span id="3606">3606</span>
<span id="3607">3607</span>
<span id="3608">3608</span>
<span id="3609">3609</span>
<span id="3610">3610</span>
<span id="3611">3611</span>
<span id="3612">3612</span>
<span id="3613">3613</span>
<span id="3614">3614</span>
<span id="3615">3615</span>
<span id="3616">3616</span>
<span id="3617">3617</span>
<span id="3618">3618</span>
<span id="3619">3619</span>
<span id="3620">3620</span>
<span id="3621">3621</span>
<span id="3622">3622</span>
<span id="3623">3623</span>
<span id="3624">3624</span>
<span id="3625">3625</span>
<span id="3626">3626</span>
<span id="3627">3627</span>
<span id="3628">3628</span>
<span id="3629">3629</span>
<span id="3630">3630</span>
<span id="3631">3631</span>
<span id="3632">3632</span>
<span id="3633">3633</span>
<span id="3634">3634</span>
<span id="3635">3635</span>
<span id="3636">3636</span>
<span id="3637">3637</span>
<span id="3638">3638</span>
<span id="3639">3639</span>
<span id="3640">3640</span>
<span id="3641">3641</span>
<span id="3642">3642</span>
<span id="3643">3643</span>
<span id="3644">3644</span>
<span id="3645">3645</span>
<span id="3646">3646</span>
<span id="3647">3647</span>
<span id="3648">3648</span>
<span id="3649">3649</span>
<span id="3650">3650</span>
<span id="3651">3651</span>
<span id="3652">3652</span>
<span id="3653">3653</span>
<span id="3654">3654</span>
<span id="3655">3655</span>
<span id="3656">3656</span>
<span id="3657">3657</span>
<span id="3658">3658</span>
<span id="3659">3659</span>
<span id="3660">3660</span>
<span id="3661">3661</span>
<span id="3662">3662</span>
<span id="3663">3663</span>
<span id="3664">3664</span>
<span id="3665">3665</span>
<span id="3666">3666</span>
<span id="3667">3667</span>
<span id="3668">3668</span>
<span id="3669">3669</span>
<span id="3670">3670</span>
<span id="3671">3671</span>
<span id="3672">3672</span>
<span id="3673">3673</span>
<span id="3674">3674</span>
<span id="3675">3675</span>
<span id="3676">3676</span>
<span id="3677">3677</span>
<span id="3678">3678</span>
<span id="3679">3679</span>
<span id="3680">3680</span>
<span id="3681">3681</span>
<span id="3682">3682</span>
<span id="3683">3683</span>
<span id="3684">3684</span>
<span id="3685">3685</span>
<span id="3686">3686</span>
<span id="3687">3687</span>
<span id="3688">3688</span>
<span id="3689">3689</span>
<span id="3690">3690</span>
<span id="3691">3691</span>
<span id="3692">3692</span>
<span id="3693">3693</span>
<span id="3694">3694</span>
<span id="3695">3695</span>
<span id="3696">3696</span>
<span id="3697">3697</span>
<span id="3698">3698</span>
<span id="3699">3699</span>
<span id="3700">3700</span>
<span id="3701">3701</span>
<span id="3702">3702</span>
<span id="3703">3703</span>
<span id="3704">3704</span>
<span id="3705">3705</span>
<span id="3706">3706</span>
<span id="3707">3707</span>
<span id="3708">3708</span>
<span id="3709">3709</span>
<span id="3710">3710</span>
<span id="3711">3711</span>
<span id="3712">3712</span>
<span id="3713">3713</span>
<span id="3714">3714</span>
<span id="3715">3715</span>
<span id="3716">3716</span>
<span id="3717">3717</span>
<span id="3718">3718</span>
<span id="3719">3719</span>
<span id="3720">3720</span>
<span id="3721">3721</span>
<span id="3722">3722</span>
<span id="3723">3723</span>
<span id="3724">3724</span>
<span id="3725">3725</span>
<span id="3726">3726</span>
<span id="3727">3727</span>
<span id="3728">3728</span>
<span id="3729">3729</span>
<span id="3730">3730</span>
<span id="3731">3731</span>
<span id="3732">3732</span>
<span id="3733">3733</span>
<span id="3734">3734</span>
<span id="3735">3735</span>
<span id="3736">3736</span>
<span id="3737">3737</span>
<span id="3738">3738</span>
<span id="3739">3739</span>
<span id="3740">3740</span>
<span id="3741">3741</span>
<span id="3742">3742</span>
<span id="3743">3743</span>
<span id="3744">3744</span>
<span id="3745">3745</span>
<span id="3746">3746</span>
<span id="3747">3747</span>
<span id="3748">3748</span>
<span id="3749">3749</span>
<span id="3750">3750</span>
<span id="3751">3751</span>
<span id="3752">3752</span>
<span id="3753">3753</span>
<span id="3754">3754</span>
<span id="3755">3755</span>
<span id="3756">3756</span>
<span id="3757">3757</span>
<span id="3758">3758</span>
<span id="3759">3759</span>
<span id="3760">3760</span>
<span id="3761">3761</span>
<span id="3762">3762</span>
<span id="3763">3763</span>
<span id="3764">3764</span>
<span id="3765">3765</span>
<span id="3766">3766</span>
<span id="3767">3767</span>
<span id="3768">3768</span>
<span id="3769">3769</span>
<span id="3770">3770</span>
<span id="3771">3771</span>
<span id="3772">3772</span>
<span id="3773">3773</span>
<span id="3774">3774</span>
<span id="3775">3775</span>
<span id="3776">3776</span>
<span id="3777">3777</span>
<span id="3778">3778</span>
<span id="3779">3779</span>
<span id="3780">3780</span>
<span id="3781">3781</span>
<span id="3782">3782</span>
<span id="3783">3783</span>
<span id="3784">3784</span>
<span id="3785">3785</span>
<span id="3786">3786</span>
<span id="3787">3787</span>
<span id="3788">3788</span>
<span id="3789">3789</span>
<span id="3790">3790</span>
<span id="3791">3791</span>
<span id="3792">3792</span>
<span id="3793">3793</span>
<span id="3794">3794</span>
<span id="3795">3795</span>
<span id="3796">3796</span>
<span id="3797">3797</span>
<span id="3798">3798</span>
<span id="3799">3799</span>
<span id="3800">3800</span>
<span id="3801">3801</span>
<span id="3802">3802</span>
<span id="3803">3803</span>
<span id="3804">3804</span>
<span id="3805">3805</span>
<span id="3806">3806</span>
<span id="3807">3807</span>
<span id="3808">3808</span>
<span id="3809">3809</span>
<span id="3810">3810</span>
<span id="3811">3811</span>
<span id="3812">3812</span>
<span id="3813">3813</span>
<span id="3814">3814</span>
<span id="3815">3815</span>
<span id="3816">3816</span>
<span id="3817">3817</span>
<span id="3818">3818</span>
<span id="3819">3819</span>
<span id="3820">3820</span>
<span id="3821">3821</span>
<span id="3822">3822</span>
<span id="3823">3823</span>
<span id="3824">3824</span>
<span id="3825">3825</span>
<span id="3826">3826</span>
<span id="3827">3827</span>
<span id="3828">3828</span>
<span id="3829">3829</span>
<span id="3830">3830</span>
<span id="3831">3831</span>
<span id="3832">3832</span>
<span id="3833">3833</span>
<span id="3834">3834</span>
<span id="3835">3835</span>
<span id="3836">3836</span>
<span id="3837">3837</span>
<span id="3838">3838</span>
<span id="3839">3839</span>
<span id="3840">3840</span>
<span id="3841">3841</span>
<span id="3842">3842</span>
<span id="3843">3843</span>
<span id="3844">3844</span>
<span id="3845">3845</span>
<span id="3846">3846</span>
<span id="3847">3847</span>
<span id="3848">3848</span>
<span id="3849">3849</span>
<span id="3850">3850</span>
<span id="3851">3851</span>
<span id="3852">3852</span>
<span id="3853">3853</span>
<span id="3854">3854</span>
<span id="3855">3855</span>
<span id="3856">3856</span>
<span id="3857">3857</span>
<span id="3858">3858</span>
<span id="3859">3859</span>
<span id="3860">3860</span>
<span id="3861">3861</span>
<span id="3862">3862</span>
<span id="3863">3863</span>
<span id="3864">3864</span>
<span id="3865">3865</span>
<span id="3866">3866</span>
<span id="3867">3867</span>
<span id="3868">3868</span>
<span id="3869">3869</span>
<span id="3870">3870</span>
<span id="3871">3871</span>
<span id="3872">3872</span>
<span id="3873">3873</span>
<span id="3874">3874</span>
<span id="3875">3875</span>
<span id="3876">3876</span>
<span id="3877">3877</span>
<span id="3878">3878</span>
<span id="3879">3879</span>
<span id="3880">3880</span>
<span id="3881">3881</span>
<span id="3882">3882</span>
<span id="3883">3883</span>
<span id="3884">3884</span>
<span id="3885">3885</span>
<span id="3886">3886</span>
<span id="3887">3887</span>
<span id="3888">3888</span>
<span id="3889">3889</span>
<span id="3890">3890</span>
<span id="3891">3891</span>
<span id="3892">3892</span>
<span id="3893">3893</span>
<span id="3894">3894</span>
<span id="3895">3895</span>
<span id="3896">3896</span>
<span id="3897">3897</span>
<span id="3898">3898</span>
<span id="3899">3899</span>
<span id="3900">3900</span>
<span id="3901">3901</span>
<span id="3902">3902</span>
<span id="3903">3903</span>
<span id="3904">3904</span>
<span id="3905">3905</span>
<span id="3906">3906</span>
<span id="3907">3907</span>
<span id="3908">3908</span>
<span id="3909">3909</span>
<span id="3910">3910</span>
<span id="3911">3911</span>
<span id="3912">3912</span>
<span id="3913">3913</span>
<span id="3914">3914</span>
<span id="3915">3915</span>
<span id="3916">3916</span>
<span id="3917">3917</span>
<span id="3918">3918</span>
<span id="3919">3919</span>
<span id="3920">3920</span>
<span id="3921">3921</span>
<span id="3922">3922</span>
<span id="3923">3923</span>
<span id="3924">3924</span>
<span id="3925">3925</span>
<span id="3926">3926</span>
<span id="3927">3927</span>
<span id="3928">3928</span>
<span id="3929">3929</span>
<span id="3930">3930</span>
<span id="3931">3931</span>
<span id="3932">3932</span>
<span id="3933">3933</span>
<span id="3934">3934</span>
<span id="3935">3935</span>
<span id="3936">3936</span>
<span id="3937">3937</span>
<span id="3938">3938</span>
<span id="3939">3939</span>
<span id="3940">3940</span>
<span id="3941">3941</span>
<span id="3942">3942</span>
<span id="3943">3943</span>
<span id="3944">3944</span>
<span id="3945">3945</span>
<span id="3946">3946</span>
<span id="3947">3947</span>
<span id="3948">3948</span>
<span id="3949">3949</span>
<span id="3950">3950</span>
<span id="3951">3951</span>
<span id="3952">3952</span>
<span id="3953">3953</span>
<span id="3954">3954</span>
<span id="3955">3955</span>
<span id="3956">3956</span>
<span id="3957">3957</span>
<span id="3958">3958</span>
<span id="3959">3959</span>
<span id="3960">3960</span>
<span id="3961">3961</span>
<span id="3962">3962</span>
<span id="3963">3963</span>
<span id="3964">3964</span>
<span id="3965">3965</span>
<span id="3966">3966</span>
<span id="3967">3967</span>
<span id="3968">3968</span>
<span id="3969">3969</span>
<span id="3970">3970</span>
<span id="3971">3971</span>
<span id="3972">3972</span>
<span id="3973">3973</span>
<span id="3974">3974</span>
<span id="3975">3975</span>
<span id="3976">3976</span>
<span id="3977">3977</span>
<span id="3978">3978</span>
<span id="3979">3979</span>
<span id="3980">3980</span>
<span id="3981">3981</span>
<span id="3982">3982</span>
<span id="3983">3983</span>
<span id="3984">3984</span>
<span id="3985">3985</span>
<span id="3986">3986</span>
<span id="3987">3987</span>
<span id="3988">3988</span>
<span id="3989">3989</span>
<span id="3990">3990</span>
<span id="3991">3991</span>
<span id="3992">3992</span>
<span id="3993">3993</span>
<span id="3994">3994</span>
<span id="3995">3995</span>
<span id="3996">3996</span>
<span id="3997">3997</span>
<span id="3998">3998</span>
<span id="3999">3999</span>
<span id="4000">4000</span>
<span id="4001">4001</span>
<span id="4002">4002</span>
<span id="4003">4003</span>
<span id="4004">4004</span>
<span id="4005">4005</span>
<span id="4006">4006</span>
<span id="4007">4007</span>
<span id="4008">4008</span>
<span id="4009">4009</span>
<span id="4010">4010</span>
<span id="4011">4011</span>
<span id="4012">4012</span>
<span id="4013">4013</span>
<span id="4014">4014</span>
<span id="4015">4015</span>
<span id="4016">4016</span>
<span id="4017">4017</span>
<span id="4018">4018</span>
<span id="4019">4019</span>
<span id="4020">4020</span>
<span id="4021">4021</span>
<span id="4022">4022</span>
<span id="4023">4023</span>
<span id="4024">4024</span>
<span id="4025">4025</span>
<span id="4026">4026</span>
<span id="4027">4027</span>
<span id="4028">4028</span>
<span id="4029">4029</span>
<span id="4030">4030</span>
<span id="4031">4031</span>
<span id="4032">4032</span>
<span id="4033">4033</span>
<span id="4034">4034</span>
<span id="4035">4035</span>
<span id="4036">4036</span>
<span id="4037">4037</span>
<span id="4038">4038</span>
<span id="4039">4039</span>
<span id="4040">4040</span>
<span id="4041">4041</span>
<span id="4042">4042</span>
<span id="4043">4043</span>
<span id="4044">4044</span>
<span id="4045">4045</span>
<span id="4046">4046</span>
<span id="4047">4047</span>
<span id="4048">4048</span>
<span id="4049">4049</span>
<span id="4050">4050</span>
<span id="4051">4051</span>
<span id="4052">4052</span>
<span id="4053">4053</span>
<span id="4054">4054</span>
<span id="4055">4055</span>
<span id="4056">4056</span>
<span id="4057">4057</span>
<span id="4058">4058</span>
<span id="4059">4059</span>
<span id="4060">4060</span>
<span id="4061">4061</span>
<span id="4062">4062</span>
<span id="4063">4063</span>
<span id="4064">4064</span>
<span id="4065">4065</span>
<span id="4066">4066</span>
<span id="4067">4067</span>
<span id="4068">4068</span>
<span id="4069">4069</span>
<span id="4070">4070</span>
<span id="4071">4071</span>
<span id="4072">4072</span>
<span id="4073">4073</span>
<span id="4074">4074</span>
<span id="4075">4075</span>
<span id="4076">4076</span>
<span id="4077">4077</span>
<span id="4078">4078</span>
<span id="4079">4079</span>
<span id="4080">4080</span>
<span id="4081">4081</span>
<span id="4082">4082</span>
<span id="4083">4083</span>
<span id="4084">4084</span>
<span id="4085">4085</span>
<span id="4086">4086</span>
<span id="4087">4087</span>
<span id="4088">4088</span>
<span id="4089">4089</span>
<span id="4090">4090</span>
<span id="4091">4091</span>
<span id="4092">4092</span>
<span id="4093">4093</span>
<span id="4094">4094</span>
<span id="4095">4095</span>
<span id="4096">4096</span>
<span id="4097">4097</span>
<span id="4098">4098</span>
<span id="4099">4099</span>
<span id="4100">4100</span>
<span id="4101">4101</span>
<span id="4102">4102</span>
<span id="4103">4103</span>
<span id="4104">4104</span>
<span id="4105">4105</span>
<span id="4106">4106</span>
<span id="4107">4107</span>
<span id="4108">4108</span>
<span id="4109">4109</span>
<span id="4110">4110</span>
<span id="4111">4111</span>
<span id="4112">4112</span>
<span id="4113">4113</span>
<span id="4114">4114</span>
<span id="4115">4115</span>
<span id="4116">4116</span>
<span id="4117">4117</span>
<span id="4118">4118</span>
<span id="4119">4119</span>
<span id="4120">4120</span>
<span id="4121">4121</span>
<span id="4122">4122</span>
<span id="4123">4123</span>
<span id="4124">4124</span>
<span id="4125">4125</span>
<span id="4126">4126</span>
<span id="4127">4127</span>
<span id="4128">4128</span>
<span id="4129">4129</span>
<span id="4130">4130</span>
<span id="4131">4131</span>
<span id="4132">4132</span>
<span id="4133">4133</span>
<span id="4134">4134</span>
<span id="4135">4135</span>
<span id="4136">4136</span>
<span id="4137">4137</span>
<span id="4138">4138</span>
<span id="4139">4139</span>
<span id="4140">4140</span>
<span id="4141">4141</span>
<span id="4142">4142</span>
<span id="4143">4143</span>
<span id="4144">4144</span>
<span id="4145">4145</span>
<span id="4146">4146</span>
<span id="4147">4147</span>
<span id="4148">4148</span>
<span id="4149">4149</span>
<span id="4150">4150</span>
<span id="4151">4151</span>
<span id="4152">4152</span>
<span id="4153">4153</span>
<span id="4154">4154</span>
<span id="4155">4155</span>
<span id="4156">4156</span>
<span id="4157">4157</span>
<span id="4158">4158</span>
<span id="4159">4159</span>
<span id="4160">4160</span>
<span id="4161">4161</span>
<span id="4162">4162</span>
<span id="4163">4163</span>
<span id="4164">4164</span>
<span id="4165">4165</span>
<span id="4166">4166</span>
<span id="4167">4167</span>
<span id="4168">4168</span>
<span id="4169">4169</span>
<span id="4170">4170</span>
<span id="4171">4171</span>
<span id="4172">4172</span>
<span id="4173">4173</span>
<span id="4174">4174</span>
<span id="4175">4175</span>
<span id="4176">4176</span>
<span id="4177">4177</span>
<span id="4178">4178</span>
<span id="4179">4179</span>
<span id="4180">4180</span>
<span id="4181">4181</span>
<span id="4182">4182</span>
<span id="4183">4183</span>
<span id="4184">4184</span>
<span id="4185">4185</span>
<span id="4186">4186</span>
<span id="4187">4187</span>
<span id="4188">4188</span>
<span id="4189">4189</span>
<span id="4190">4190</span>
<span id="4191">4191</span>
<span id="4192">4192</span>
<span id="4193">4193</span>
<span id="4194">4194</span>
<span id="4195">4195</span>
<span id="4196">4196</span>
<span id="4197">4197</span>
<span id="4198">4198</span>
<span id="4199">4199</span>
<span id="4200">4200</span>
<span id="4201">4201</span>
<span id="4202">4202</span>
<span id="4203">4203</span>
<span id="4204">4204</span>
<span id="4205">4205</span>
<span id="4206">4206</span>
<span id="4207">4207</span>
<span id="4208">4208</span>
<span id="4209">4209</span>
<span id="4210">4210</span>
<span id="4211">4211</span>
<span id="4212">4212</span>
<span id="4213">4213</span>
<span id="4214">4214</span>
<span id="4215">4215</span>
<span id="4216">4216</span>
<span id="4217">4217</span>
<span id="4218">4218</span>
<span id="4219">4219</span>
<span id="4220">4220</span>
<span id="4221">4221</span>
<span id="4222">4222</span>
<span id="4223">4223</span>
<span id="4224">4224</span>
<span id="4225">4225</span>
<span id="4226">4226</span>
<span id="4227">4227</span>
<span id="4228">4228</span>
<span id="4229">4229</span>
<span id="4230">4230</span>
<span id="4231">4231</span>
<span id="4232">4232</span>
<span id="4233">4233</span>
<span id="4234">4234</span>
<span id="4235">4235</span>
<span id="4236">4236</span>
<span id="4237">4237</span>
<span id="4238">4238</span>
<span id="4239">4239</span>
<span id="4240">4240</span>
<span id="4241">4241</span>
<span id="4242">4242</span>
<span id="4243">4243</span>
<span id="4244">4244</span>
<span id="4245">4245</span>
<span id="4246">4246</span>
<span id="4247">4247</span>
<span id="4248">4248</span>
<span id="4249">4249</span>
<span id="4250">4250</span>
<span id="4251">4251</span>
<span id="4252">4252</span>
<span id="4253">4253</span>
<span id="4254">4254</span>
<span id="4255">4255</span>
<span id="4256">4256</span>
<span id="4257">4257</span>
<span id="4258">4258</span>
<span id="4259">4259</span>
<span id="4260">4260</span>
<span id="4261">4261</span>
<span id="4262">4262</span>
<span id="4263">4263</span>
<span id="4264">4264</span>
<span id="4265">4265</span>
<span id="4266">4266</span>
<span id="4267">4267</span>
<span id="4268">4268</span>
<span id="4269">4269</span>
<span id="4270">4270</span>
<span id="4271">4271</span>
<span id="4272">4272</span>
<span id="4273">4273</span>
<span id="4274">4274</span>
<span id="4275">4275</span>
<span id="4276">4276</span>
<span id="4277">4277</span>
<span id="4278">4278</span>
<span id="4279">4279</span>
<span id="4280">4280</span>
<span id="4281">4281</span>
<span id="4282">4282</span>
<span id="4283">4283</span>
<span id="4284">4284</span>
<span id="4285">4285</span>
<span id="4286">4286</span>
<span id="4287">4287</span>
<span id="4288">4288</span>
<span id="4289">4289</span>
<span id="4290">4290</span>
<span id="4291">4291</span>
<span id="4292">4292</span>
<span id="4293">4293</span>
<span id="4294">4294</span>
<span id="4295">4295</span>
<span id="4296">4296</span>
<span id="4297">4297</span>
<span id="4298">4298</span>
<span id="4299">4299</span>
<span id="4300">4300</span>
<span id="4301">4301</span>
<span id="4302">4302</span>
<span id="4303">4303</span>
<span id="4304">4304</span>
<span id="4305">4305</span>
<span id="4306">4306</span>
<span id="4307">4307</span>
<span id="4308">4308</span>
<span id="4309">4309</span>
<span id="4310">4310</span>
<span id="4311">4311</span>
<span id="4312">4312</span>
<span id="4313">4313</span>
<span id="4314">4314</span>
<span id="4315">4315</span>
<span id="4316">4316</span>
<span id="4317">4317</span>
<span id="4318">4318</span>
<span id="4319">4319</span>
<span id="4320">4320</span>
<span id="4321">4321</span>
<span id="4322">4322</span>
<span id="4323">4323</span>
<span id="4324">4324</span>
<span id="4325">4325</span>
<span id="4326">4326</span>
<span id="4327">4327</span>
<span id="4328">4328</span>
<span id="4329">4329</span>
<span id="4330">4330</span>
<span id="4331">4331</span>
<span id="4332">4332</span>
<span id="4333">4333</span>
<span id="4334">4334</span>
<span id="4335">4335</span>
<span id="4336">4336</span>
<span id="4337">4337</span>
<span id="4338">4338</span>
<span id="4339">4339</span>
<span id="4340">4340</span>
<span id="4341">4341</span>
<span id="4342">4342</span>
<span id="4343">4343</span>
<span id="4344">4344</span>
<span id="4345">4345</span>
<span id="4346">4346</span>
<span id="4347">4347</span>
<span id="4348">4348</span>
<span id="4349">4349</span>
<span id="4350">4350</span>
<span id="4351">4351</span>
<span id="4352">4352</span>
<span id="4353">4353</span>
<span id="4354">4354</span>
<span id="4355">4355</span>
<span id="4356">4356</span>
<span id="4357">4357</span>
<span id="4358">4358</span>
<span id="4359">4359</span>
<span id="4360">4360</span>
<span id="4361">4361</span>
<span id="4362">4362</span>
<span id="4363">4363</span>
<span id="4364">4364</span>
<span id="4365">4365</span>
<span id="4366">4366</span>
<span id="4367">4367</span>
<span id="4368">4368</span>
<span id="4369">4369</span>
<span id="4370">4370</span>
<span id="4371">4371</span>
<span id="4372">4372</span>
<span id="4373">4373</span>
<span id="4374">4374</span>
<span id="4375">4375</span>
<span id="4376">4376</span>
<span id="4377">4377</span>
<span id="4378">4378</span>
<span id="4379">4379</span>
<span id="4380">4380</span>
<span id="4381">4381</span>
<span id="4382">4382</span>
<span id="4383">4383</span>
<span id="4384">4384</span>
<span id="4385">4385</span>
<span id="4386">4386</span>
<span id="4387">4387</span>
<span id="4388">4388</span>
<span id="4389">4389</span>
<span id="4390">4390</span>
<span id="4391">4391</span>
<span id="4392">4392</span>
<span id="4393">4393</span>
<span id="4394">4394</span>
<span id="4395">4395</span>
<span id="4396">4396</span>
<span id="4397">4397</span>
<span id="4398">4398</span>
<span id="4399">4399</span>
<span id="4400">4400</span>
<span id="4401">4401</span>
<span id="4402">4402</span>
<span id="4403">4403</span>
<span id="4404">4404</span>
<span id="4405">4405</span>
<span id="4406">4406</span>
<span id="4407">4407</span>
<span id="4408">4408</span>
<span id="4409">4409</span>
<span id="4410">4410</span>
<span id="4411">4411</span>
<span id="4412">4412</span>
<span id="4413">4413</span>
<span id="4414">4414</span>
<span id="4415">4415</span>
<span id="4416">4416</span>
<span id="4417">4417</span>
<span id="4418">4418</span>
<span id="4419">4419</span>
<span id="4420">4420</span>
<span id="4421">4421</span>
<span id="4422">4422</span>
<span id="4423">4423</span>
<span id="4424">4424</span>
<span id="4425">4425</span>
<span id="4426">4426</span>
<span id="4427">4427</span>
<span id="4428">4428</span>
<span id="4429">4429</span>
<span id="4430">4430</span>
<span id="4431">4431</span>
<span id="4432">4432</span>
<span id="4433">4433</span>
<span id="4434">4434</span>
<span id="4435">4435</span>
<span id="4436">4436</span>
<span id="4437">4437</span>
<span id="4438">4438</span>
<span id="4439">4439</span>
<span id="4440">4440</span>
<span id="4441">4441</span>
<span id="4442">4442</span>
<span id="4443">4443</span>
<span id="4444">4444</span>
<span id="4445">4445</span>
<span id="4446">4446</span>
<span id="4447">4447</span>
<span id="4448">4448</span>
<span id="4449">4449</span>
<span id="4450">4450</span>
<span id="4451">4451</span>
<span id="4452">4452</span>
<span id="4453">4453</span>
<span id="4454">4454</span>
<span id="4455">4455</span>
<span id="4456">4456</span>
<span id="4457">4457</span>
<span id="4458">4458</span>
<span id="4459">4459</span>
<span id="4460">4460</span>
<span id="4461">4461</span>
<span id="4462">4462</span>
<span id="4463">4463</span>
<span id="4464">4464</span>
<span id="4465">4465</span>
<span id="4466">4466</span>
<span id="4467">4467</span>
<span id="4468">4468</span>
<span id="4469">4469</span>
<span id="4470">4470</span>
<span id="4471">4471</span>
<span id="4472">4472</span>
<span id="4473">4473</span>
<span id="4474">4474</span>
<span id="4475">4475</span>
<span id="4476">4476</span>
<span id="4477">4477</span>
<span id="4478">4478</span>
<span id="4479">4479</span>
<span id="4480">4480</span>
<span id="4481">4481</span>
<span id="4482">4482</span>
<span id="4483">4483</span>
<span id="4484">4484</span>
<span id="4485">4485</span>
<span id="4486">4486</span>
<span id="4487">4487</span>
<span id="4488">4488</span>
<span id="4489">4489</span>
<span id="4490">4490</span>
<span id="4491">4491</span>
<span id="4492">4492</span>
<span id="4493">4493</span>
<span id="4494">4494</span>
<span id="4495">4495</span>
<span id="4496">4496</span>
<span id="4497">4497</span>
<span id="4498">4498</span>
<span id="4499">4499</span>
<span id="4500">4500</span>
<span id="4501">4501</span>
<span id="4502">4502</span>
<span id="4503">4503</span>
<span id="4504">4504</span>
<span id="4505">4505</span>
<span id="4506">4506</span>
<span id="4507">4507</span>
<span id="4508">4508</span>
<span id="4509">4509</span>
<span id="4510">4510</span>
<span id="4511">4511</span>
<span id="4512">4512</span>
<span id="4513">4513</span>
<span id="4514">4514</span>
<span id="4515">4515</span>
<span id="4516">4516</span>
<span id="4517">4517</span>
<span id="4518">4518</span>
<span id="4519">4519</span>
<span id="4520">4520</span>
<span id="4521">4521</span>
<span id="4522">4522</span>
<span id="4523">4523</span>
<span id="4524">4524</span>
<span id="4525">4525</span>
<span id="4526">4526</span>
<span id="4527">4527</span>
<span id="4528">4528</span>
<span id="4529">4529</span>
<span id="4530">4530</span>
<span id="4531">4531</span>
<span id="4532">4532</span>
<span id="4533">4533</span>
<span id="4534">4534</span>
<span id="4535">4535</span>
<span id="4536">4536</span>
<span id="4537">4537</span>
<span id="4538">4538</span>
<span id="4539">4539</span>
<span id="4540">4540</span>
<span id="4541">4541</span>
<span id="4542">4542</span>
<span id="4543">4543</span>
<span id="4544">4544</span>
<span id="4545">4545</span>
<span id="4546">4546</span>
<span id="4547">4547</span>
<span id="4548">4548</span>
<span id="4549">4549</span>
<span id="4550">4550</span>
<span id="4551">4551</span>
<span id="4552">4552</span>
<span id="4553">4553</span>
<span id="4554">4554</span>
<span id="4555">4555</span>
<span id="4556">4556</span>
<span id="4557">4557</span>
<span id="4558">4558</span>
<span id="4559">4559</span>
<span id="4560">4560</span>
<span id="4561">4561</span>
<span id="4562">4562</span>
<span id="4563">4563</span>
<span id="4564">4564</span>
<span id="4565">4565</span>
<span id="4566">4566</span>
<span id="4567">4567</span>
<span id="4568">4568</span>
<span id="4569">4569</span>
<span id="4570">4570</span>
<span id="4571">4571</span>
<span id="4572">4572</span>
<span id="4573">4573</span>
<span id="4574">4574</span>
<span id="4575">4575</span>
<span id="4576">4576</span>
<span id="4577">4577</span>
<span id="4578">4578</span>
<span id="4579">4579</span>
<span id="4580">4580</span>
<span id="4581">4581</span>
<span id="4582">4582</span>
<span id="4583">4583</span>
<span id="4584">4584</span>
<span id="4585">4585</span>
<span id="4586">4586</span>
<span id="4587">4587</span>
<span id="4588">4588</span>
<span id="4589">4589</span>
<span id="4590">4590</span>
<span id="4591">4591</span>
<span id="4592">4592</span>
<span id="4593">4593</span>
<span id="4594">4594</span>
<span id="4595">4595</span>
<span id="4596">4596</span>
<span id="4597">4597</span>
<span id="4598">4598</span>
<span id="4599">4599</span>
<span id="4600">4600</span>
<span id="4601">4601</span>
<span id="4602">4602</span>
<span id="4603">4603</span>
<span id="4604">4604</span>
<span id="4605">4605</span>
<span id="4606">4606</span>
<span id="4607">4607</span>
<span id="4608">4608</span>
<span id="4609">4609</span>
<span id="4610">4610</span>
<span id="4611">4611</span>
<span id="4612">4612</span>
<span id="4613">4613</span>
<span id="4614">4614</span>
<span id="4615">4615</span>
<span id="4616">4616</span>
<span id="4617">4617</span>
<span id="4618">4618</span>
<span id="4619">4619</span>
<span id="4620">4620</span>
<span id="4621">4621</span>
<span id="4622">4622</span>
<span id="4623">4623</span>
<span id="4624">4624</span>
<span id="4625">4625</span>
<span id="4626">4626</span>
<span id="4627">4627</span>
<span id="4628">4628</span>
<span id="4629">4629</span>
<span id="4630">4630</span>
<span id="4631">4631</span>
<span id="4632">4632</span>
<span id="4633">4633</span>
<span id="4634">4634</span>
<span id="4635">4635</span>
<span id="4636">4636</span>
<span id="4637">4637</span>
<span id="4638">4638</span>
<span id="4639">4639</span>
<span id="4640">4640</span>
<span id="4641">4641</span>
<span id="4642">4642</span>
<span id="4643">4643</span>
<span id="4644">4644</span>
<span id="4645">4645</span>
<span id="4646">4646</span>
<span id="4647">4647</span>
<span id="4648">4648</span>
<span id="4649">4649</span>
<span id="4650">4650</span>
<span id="4651">4651</span>
<span id="4652">4652</span>
<span id="4653">4653</span>
<span id="4654">4654</span>
<span id="4655">4655</span>
<span id="4656">4656</span>
<span id="4657">4657</span>
<span id="4658">4658</span>
<span id="4659">4659</span>
<span id="4660">4660</span>
<span id="4661">4661</span>
<span id="4662">4662</span>
<span id="4663">4663</span>
<span id="4664">4664</span>
<span id="4665">4665</span>
<span id="4666">4666</span>
<span id="4667">4667</span>
<span id="4668">4668</span>
<span id="4669">4669</span>
<span id="4670">4670</span>
<span id="4671">4671</span>
<span id="4672">4672</span>
<span id="4673">4673</span>
<span id="4674">4674</span>
<span id="4675">4675</span>
<span id="4676">4676</span>
<span id="4677">4677</span>
<span id="4678">4678</span>
<span id="4679">4679</span>
<span id="4680">4680</span>
<span id="4681">4681</span>
<span id="4682">4682</span>
<span id="4683">4683</span>
<span id="4684">4684</span>
<span id="4685">4685</span>
<span id="4686">4686</span>
<span id="4687">4687</span>
<span id="4688">4688</span>
<span id="4689">4689</span>
<span id="4690">4690</span>
<span id="4691">4691</span>
<span id="4692">4692</span>
<span id="4693">4693</span>
<span id="4694">4694</span>
<span id="4695">4695</span>
<span id="4696">4696</span>
<span id="4697">4697</span>
<span id="4698">4698</span>
<span id="4699">4699</span>
<span id="4700">4700</span>
<span id="4701">4701</span>
<span id="4702">4702</span>
<span id="4703">4703</span>
<span id="4704">4704</span>
<span id="4705">4705</span>
<span id="4706">4706</span>
<span id="4707">4707</span>
<span id="4708">4708</span>
<span id="4709">4709</span>
<span id="4710">4710</span>
<span id="4711">4711</span>
<span id="4712">4712</span>
<span id="4713">4713</span>
<span id="4714">4714</span>
<span id="4715">4715</span>
<span id="4716">4716</span>
<span id="4717">4717</span>
<span id="4718">4718</span>
<span id="4719">4719</span>
<span id="4720">4720</span>
<span id="4721">4721</span>
<span id="4722">4722</span>
<span id="4723">4723</span>
<span id="4724">4724</span>
<span id="4725">4725</span>
<span id="4726">4726</span>
<span id="4727">4727</span>
<span id="4728">4728</span>
<span id="4729">4729</span>
<span id="4730">4730</span>
<span id="4731">4731</span>
<span id="4732">4732</span>
<span id="4733">4733</span>
<span id="4734">4734</span>
<span id="4735">4735</span>
<span id="4736">4736</span>
<span id="4737">4737</span>
<span id="4738">4738</span>
<span id="4739">4739</span>
<span id="4740">4740</span>
<span id="4741">4741</span>
<span id="4742">4742</span>
<span id="4743">4743</span>
<span id="4744">4744</span>
<span id="4745">4745</span>
<span id="4746">4746</span>
<span id="4747">4747</span>
<span id="4748">4748</span>
<span id="4749">4749</span>
<span id="4750">4750</span>
<span id="4751">4751</span>
<span id="4752">4752</span>
<span id="4753">4753</span>
<span id="4754">4754</span>
<span id="4755">4755</span>
<span id="4756">4756</span>
<span id="4757">4757</span>
<span id="4758">4758</span>
<span id="4759">4759</span>
<span id="4760">4760</span>
<span id="4761">4761</span>
<span id="4762">4762</span>
<span id="4763">4763</span>
<span id="4764">4764</span>
<span id="4765">4765</span>
<span id="4766">4766</span>
<span id="4767">4767</span>
<span id="4768">4768</span>
<span id="4769">4769</span>
<span id="4770">4770</span>
<span id="4771">4771</span>
<span id="4772">4772</span>
<span id="4773">4773</span>
<span id="4774">4774</span>
<span id="4775">4775</span>
<span id="4776">4776</span>
<span id="4777">4777</span>
<span id="4778">4778</span>
<span id="4779">4779</span>
<span id="4780">4780</span>
<span id="4781">4781</span>
<span id="4782">4782</span>
<span id="4783">4783</span>
<span id="4784">4784</span>
<span id="4785">4785</span>
<span id="4786">4786</span>
<span id="4787">4787</span>
<span id="4788">4788</span>
<span id="4789">4789</span>
<span id="4790">4790</span>
<span id="4791">4791</span>
<span id="4792">4792</span>
<span id="4793">4793</span>
<span id="4794">4794</span>
<span id="4795">4795</span>
<span id="4796">4796</span>
<span id="4797">4797</span>
<span id="4798">4798</span>
<span id="4799">4799</span>
<span id="4800">4800</span>
<span id="4801">4801</span>
<span id="4802">4802</span>
<span id="4803">4803</span>
<span id="4804">4804</span>
<span id="4805">4805</span>
<span id="4806">4806</span>
<span id="4807">4807</span>
<span id="4808">4808</span>
<span id="4809">4809</span>
<span id="4810">4810</span>
<span id="4811">4811</span>
<span id="4812">4812</span>
<span id="4813">4813</span>
<span id="4814">4814</span>
<span id="4815">4815</span>
<span id="4816">4816</span>
<span id="4817">4817</span>
<span id="4818">4818</span>
<span id="4819">4819</span>
<span id="4820">4820</span>
<span id="4821">4821</span>
<span id="4822">4822</span>
<span id="4823">4823</span>
<span id="4824">4824</span>
<span id="4825">4825</span>
<span id="4826">4826</span>
<span id="4827">4827</span>
<span id="4828">4828</span>
<span id="4829">4829</span>
<span id="4830">4830</span>
<span id="4831">4831</span>
<span id="4832">4832</span>
<span id="4833">4833</span>
<span id="4834">4834</span>
<span id="4835">4835</span>
<span id="4836">4836</span>
<span id="4837">4837</span>
<span id="4838">4838</span>
<span id="4839">4839</span>
<span id="4840">4840</span>
<span id="4841">4841</span>
<span id="4842">4842</span>
<span id="4843">4843</span>
<span id="4844">4844</span>
<span id="4845">4845</span>
<span id="4846">4846</span>
<span id="4847">4847</span>
<span id="4848">4848</span>
<span id="4849">4849</span>
<span id="4850">4850</span>
<span id="4851">4851</span>
<span id="4852">4852</span>
<span id="4853">4853</span>
<span id="4854">4854</span>
<span id="4855">4855</span>
<span id="4856">4856</span>
<span id="4857">4857</span>
<span id="4858">4858</span>
<span id="4859">4859</span>
<span id="4860">4860</span>
<span id="4861">4861</span>
<span id="4862">4862</span>
<span id="4863">4863</span>
<span id="4864">4864</span>
<span id="4865">4865</span>
<span id="4866">4866</span>
<span id="4867">4867</span>
<span id="4868">4868</span>
<span id="4869">4869</span>
<span id="4870">4870</span>
<span id="4871">4871</span>
<span id="4872">4872</span>
<span id="4873">4873</span>
<span id="4874">4874</span>
<span id="4875">4875</span>
<span id="4876">4876</span>
<span id="4877">4877</span>
<span id="4878">4878</span>
<span id="4879">4879</span>
<span id="4880">4880</span>
<span id="4881">4881</span>
<span id="4882">4882</span>
<span id="4883">4883</span>
<span id="4884">4884</span>
<span id="4885">4885</span>
<span id="4886">4886</span>
<span id="4887">4887</span>
<span id="4888">4888</span>
<span id="4889">4889</span>
<span id="4890">4890</span>
<span id="4891">4891</span>
<span id="4892">4892</span>
<span id="4893">4893</span>
<span id="4894">4894</span>
<span id="4895">4895</span>
<span id="4896">4896</span>
<span id="4897">4897</span>
<span id="4898">4898</span>
<span id="4899">4899</span>
<span id="4900">4900</span>
<span id="4901">4901</span>
<span id="4902">4902</span>
<span id="4903">4903</span>
<span id="4904">4904</span>
<span id="4905">4905</span>
<span id="4906">4906</span>
<span id="4907">4907</span>
<span id="4908">4908</span>
<span id="4909">4909</span>
<span id="4910">4910</span>
<span id="4911">4911</span>
<span id="4912">4912</span>
<span id="4913">4913</span>
<span id="4914">4914</span>
<span id="4915">4915</span>
<span id="4916">4916</span>
<span id="4917">4917</span>
<span id="4918">4918</span>
<span id="4919">4919</span>
<span id="4920">4920</span>
<span id="4921">4921</span>
<span id="4922">4922</span>
<span id="4923">4923</span>
<span id="4924">4924</span>
<span id="4925">4925</span>
<span id="4926">4926</span>
<span id="4927">4927</span>
<span id="4928">4928</span>
<span id="4929">4929</span>
<span id="4930">4930</span>
<span id="4931">4931</span>
<span id="4932">4932</span>
<span id="4933">4933</span>
<span id="4934">4934</span>
<span id="4935">4935</span>
<span id="4936">4936</span>
<span id="4937">4937</span>
<span id="4938">4938</span>
<span id="4939">4939</span>
<span id="4940">4940</span>
<span id="4941">4941</span>
<span id="4942">4942</span>
<span id="4943">4943</span>
<span id="4944">4944</span>
<span id="4945">4945</span>
<span id="4946">4946</span>
<span id="4947">4947</span>
<span id="4948">4948</span>
<span id="4949">4949</span>
<span id="4950">4950</span>
<span id="4951">4951</span>
<span id="4952">4952</span>
<span id="4953">4953</span>
<span id="4954">4954</span>
<span id="4955">4955</span>
<span id="4956">4956</span>
<span id="4957">4957</span>
<span id="4958">4958</span>
<span id="4959">4959</span>
<span id="4960">4960</span>
<span id="4961">4961</span>
<span id="4962">4962</span>
<span id="4963">4963</span>
<span id="4964">4964</span>
<span id="4965">4965</span>
<span id="4966">4966</span>
<span id="4967">4967</span>
<span id="4968">4968</span>
<span id="4969">4969</span>
<span id="4970">4970</span>
<span id="4971">4971</span>
<span id="4972">4972</span>
<span id="4973">4973</span>
<span id="4974">4974</span>
<span id="4975">4975</span>
<span id="4976">4976</span>
<span id="4977">4977</span>
<span id="4978">4978</span>
<span id="4979">4979</span>
<span id="4980">4980</span>
<span id="4981">4981</span>
<span id="4982">4982</span>
<span id="4983">4983</span>
<span id="4984">4984</span>
<span id="4985">4985</span>
<span id="4986">4986</span>
<span id="4987">4987</span>
<span id="4988">4988</span>
<span id="4989">4989</span>
<span id="4990">4990</span>
<span id="4991">4991</span>
<span id="4992">4992</span>
<span id="4993">4993</span>
<span id="4994">4994</span>
<span id="4995">4995</span>
<span id="4996">4996</span>
<span id="4997">4997</span>
<span id="4998">4998</span>
<span id="4999">4999</span>
<span id="5000">5000</span>
<span id="5001">5001</span>
<span id="5002">5002</span>
<span id="5003">5003</span>
<span id="5004">5004</span>
<span id="5005">5005</span>
<span id="5006">5006</span>
<span id="5007">5007</span>
<span id="5008">5008</span>
<span id="5009">5009</span>
<span id="5010">5010</span>
<span id="5011">5011</span>
<span id="5012">5012</span>
<span id="5013">5013</span>
<span id="5014">5014</span>
<span id="5015">5015</span>
<span id="5016">5016</span>
<span id="5017">5017</span>
<span id="5018">5018</span>
<span id="5019">5019</span>
<span id="5020">5020</span>
<span id="5021">5021</span>
<span id="5022">5022</span>
<span id="5023">5023</span>
<span id="5024">5024</span>
<span id="5025">5025</span>
<span id="5026">5026</span>
<span id="5027">5027</span>
<span id="5028">5028</span>
<span id="5029">5029</span>
<span id="5030">5030</span>
<span id="5031">5031</span>
<span id="5032">5032</span>
<span id="5033">5033</span>
<span id="5034">5034</span>
<span id="5035">5035</span>
<span id="5036">5036</span>
<span id="5037">5037</span>
<span id="5038">5038</span>
<span id="5039">5039</span>
<span id="5040">5040</span>
<span id="5041">5041</span>
<span id="5042">5042</span>
<span id="5043">5043</span>
<span id="5044">5044</span>
<span id="5045">5045</span>
<span id="5046">5046</span>
<span id="5047">5047</span>
<span id="5048">5048</span>
<span id="5049">5049</span>
<span id="5050">5050</span>
<span id="5051">5051</span>
<span id="5052">5052</span>
<span id="5053">5053</span>
<span id="5054">5054</span>
<span id="5055">5055</span>
<span id="5056">5056</span>
<span id="5057">5057</span>
<span id="5058">5058</span>
<span id="5059">5059</span>
<span id="5060">5060</span>
<span id="5061">5061</span>
<span id="5062">5062</span>
<span id="5063">5063</span>
<span id="5064">5064</span>
<span id="5065">5065</span>
<span id="5066">5066</span>
<span id="5067">5067</span>
<span id="5068">5068</span>
<span id="5069">5069</span>
<span id="5070">5070</span>
<span id="5071">5071</span>
<span id="5072">5072</span>
<span id="5073">5073</span>
<span id="5074">5074</span>
<span id="5075">5075</span>
<span id="5076">5076</span>
<span id="5077">5077</span>
<span id="5078">5078</span>
<span id="5079">5079</span>
<span id="5080">5080</span>
<span id="5081">5081</span>
<span id="5082">5082</span>
<span id="5083">5083</span>
<span id="5084">5084</span>
<span id="5085">5085</span>
<span id="5086">5086</span>
<span id="5087">5087</span>
<span id="5088">5088</span>
<span id="5089">5089</span>
<span id="5090">5090</span>
<span id="5091">5091</span>
<span id="5092">5092</span>
<span id="5093">5093</span>
<span id="5094">5094</span>
<span id="5095">5095</span>
<span id="5096">5096</span>
<span id="5097">5097</span>
<span id="5098">5098</span>
<span id="5099">5099</span>
<span id="5100">5100</span>
<span id="5101">5101</span>
<span id="5102">5102</span>
<span id="5103">5103</span>
<span id="5104">5104</span>
<span id="5105">5105</span>
<span id="5106">5106</span>
<span id="5107">5107</span>
<span id="5108">5108</span>
<span id="5109">5109</span>
<span id="5110">5110</span>
<span id="5111">5111</span>
<span id="5112">5112</span>
<span id="5113">5113</span>
<span id="5114">5114</span>
<span id="5115">5115</span>
<span id="5116">5116</span>
<span id="5117">5117</span>
<span id="5118">5118</span>
<span id="5119">5119</span>
<span id="5120">5120</span>
<span id="5121">5121</span>
<span id="5122">5122</span>
<span id="5123">5123</span>
<span id="5124">5124</span>
<span id="5125">5125</span>
<span id="5126">5126</span>
<span id="5127">5127</span>
<span id="5128">5128</span>
<span id="5129">5129</span>
<span id="5130">5130</span>
<span id="5131">5131</span>
<span id="5132">5132</span>
<span id="5133">5133</span>
<span id="5134">5134</span>
<span id="5135">5135</span>
<span id="5136">5136</span>
<span id="5137">5137</span>
<span id="5138">5138</span>
<span id="5139">5139</span>
<span id="5140">5140</span>
<span id="5141">5141</span>
<span id="5142">5142</span>
<span id="5143">5143</span>
<span id="5144">5144</span>
<span id="5145">5145</span>
<span id="5146">5146</span>
<span id="5147">5147</span>
<span id="5148">5148</span>
<span id="5149">5149</span>
<span id="5150">5150</span>
<span id="5151">5151</span>
<span id="5152">5152</span>
<span id="5153">5153</span>
<span id="5154">5154</span>
<span id="5155">5155</span>
<span id="5156">5156</span>
<span id="5157">5157</span>
<span id="5158">5158</span>
<span id="5159">5159</span>
<span id="5160">5160</span>
<span id="5161">5161</span>
<span id="5162">5162</span>
<span id="5163">5163</span>
<span id="5164">5164</span>
<span id="5165">5165</span>
<span id="5166">5166</span>
<span id="5167">5167</span>
<span id="5168">5168</span>
<span id="5169">5169</span>
<span id="5170">5170</span>
<span id="5171">5171</span>
<span id="5172">5172</span>
<span id="5173">5173</span>
<span id="5174">5174</span>
<span id="5175">5175</span>
<span id="5176">5176</span>
<span id="5177">5177</span>
<span id="5178">5178</span>
<span id="5179">5179</span>
<span id="5180">5180</span>
<span id="5181">5181</span>
<span id="5182">5182</span>
<span id="5183">5183</span>
<span id="5184">5184</span>
<span id="5185">5185</span>
<span id="5186">5186</span>
<span id="5187">5187</span>
<span id="5188">5188</span>
<span id="5189">5189</span>
<span id="5190">5190</span>
<span id="5191">5191</span>
<span id="5192">5192</span>
<span id="5193">5193</span>
<span id="5194">5194</span>
<span id="5195">5195</span>
<span id="5196">5196</span>
<span id="5197">5197</span>
<span id="5198">5198</span>
<span id="5199">5199</span>
<span id="5200">5200</span>
<span id="5201">5201</span>
<span id="5202">5202</span>
<span id="5203">5203</span>
<span id="5204">5204</span>
<span id="5205">5205</span>
<span id="5206">5206</span>
<span id="5207">5207</span>
<span id="5208">5208</span>
<span id="5209">5209</span>
<span id="5210">5210</span>
<span id="5211">5211</span>
<span id="5212">5212</span>
<span id="5213">5213</span>
<span id="5214">5214</span>
<span id="5215">5215</span>
<span id="5216">5216</span>
<span id="5217">5217</span>
<span id="5218">5218</span>
<span id="5219">5219</span>
<span id="5220">5220</span>
<span id="5221">5221</span>
<span id="5222">5222</span>
<span id="5223">5223</span>
<span id="5224">5224</span>
<span id="5225">5225</span>
<span id="5226">5226</span>
<span id="5227">5227</span>
<span id="5228">5228</span>
<span id="5229">5229</span>
<span id="5230">5230</span>
<span id="5231">5231</span>
<span id="5232">5232</span>
<span id="5233">5233</span>
<span id="5234">5234</span>
<span id="5235">5235</span>
<span id="5236">5236</span>
<span id="5237">5237</span>
<span id="5238">5238</span>
<span id="5239">5239</span>
<span id="5240">5240</span>
<span id="5241">5241</span>
<span id="5242">5242</span>
<span id="5243">5243</span>
<span id="5244">5244</span>
<span id="5245">5245</span>
<span id="5246">5246</span>
<span id="5247">5247</span>
<span id="5248">5248</span>
<span id="5249">5249</span>
<span id="5250">5250</span>
<span id="5251">5251</span>
<span id="5252">5252</span>
<span id="5253">5253</span>
<span id="5254">5254</span>
<span id="5255">5255</span>
<span id="5256">5256</span>
<span id="5257">5257</span>
<span id="5258">5258</span>
<span id="5259">5259</span>
<span id="5260">5260</span>
<span id="5261">5261</span>
<span id="5262">5262</span>
<span id="5263">5263</span>
<span id="5264">5264</span>
<span id="5265">5265</span>
<span id="5266">5266</span>
<span id="5267">5267</span>
<span id="5268">5268</span>
<span id="5269">5269</span>
<span id="5270">5270</span>
<span id="5271">5271</span>
<span id="5272">5272</span>
<span id="5273">5273</span>
<span id="5274">5274</span>
<span id="5275">5275</span>
<span id="5276">5276</span>
<span id="5277">5277</span>
<span id="5278">5278</span>
<span id="5279">5279</span>
<span id="5280">5280</span>
<span id="5281">5281</span>
<span id="5282">5282</span>
<span id="5283">5283</span>
<span id="5284">5284</span>
<span id="5285">5285</span>
<span id="5286">5286</span>
<span id="5287">5287</span>
<span id="5288">5288</span>
<span id="5289">5289</span>
<span id="5290">5290</span>
<span id="5291">5291</span>
<span id="5292">5292</span>
<span id="5293">5293</span>
<span id="5294">5294</span>
<span id="5295">5295</span>
<span id="5296">5296</span>
<span id="5297">5297</span>
<span id="5298">5298</span>
<span id="5299">5299</span>
<span id="5300">5300</span>
<span id="5301">5301</span>
<span id="5302">5302</span>
<span id="5303">5303</span>
<span id="5304">5304</span>
<span id="5305">5305</span>
<span id="5306">5306</span>
<span id="5307">5307</span>
<span id="5308">5308</span>
<span id="5309">5309</span>
<span id="5310">5310</span>
<span id="5311">5311</span>
<span id="5312">5312</span>
<span id="5313">5313</span>
<span id="5314">5314</span>
<span id="5315">5315</span>
<span id="5316">5316</span>
<span id="5317">5317</span>
<span id="5318">5318</span>
<span id="5319">5319</span>
<span id="5320">5320</span>
<span id="5321">5321</span>
<span id="5322">5322</span>
<span id="5323">5323</span>
<span id="5324">5324</span>
<span id="5325">5325</span>
<span id="5326">5326</span>
<span id="5327">5327</span>
<span id="5328">5328</span>
<span id="5329">5329</span>
<span id="5330">5330</span>
<span id="5331">5331</span>
<span id="5332">5332</span>
<span id="5333">5333</span>
<span id="5334">5334</span>
<span id="5335">5335</span>
<span id="5336">5336</span>
<span id="5337">5337</span>
<span id="5338">5338</span>
<span id="5339">5339</span>
<span id="5340">5340</span>
<span id="5341">5341</span>
<span id="5342">5342</span>
<span id="5343">5343</span>
<span id="5344">5344</span>
<span id="5345">5345</span>
<span id="5346">5346</span>
<span id="5347">5347</span>
<span id="5348">5348</span>
<span id="5349">5349</span>
<span id="5350">5350</span>
<span id="5351">5351</span>
<span id="5352">5352</span>
<span id="5353">5353</span>
<span id="5354">5354</span>
<span id="5355">5355</span>
<span id="5356">5356</span>
<span id="5357">5357</span>
<span id="5358">5358</span>
<span id="5359">5359</span>
<span id="5360">5360</span>
<span id="5361">5361</span>
<span id="5362">5362</span>
<span id="5363">5363</span>
<span id="5364">5364</span>
<span id="5365">5365</span>
<span id="5366">5366</span>
<span id="5367">5367</span>
<span id="5368">5368</span>
<span id="5369">5369</span>
<span id="5370">5370</span>
<span id="5371">5371</span>
<span id="5372">5372</span>
<span id="5373">5373</span>
<span id="5374">5374</span>
<span id="5375">5375</span>
<span id="5376">5376</span>
<span id="5377">5377</span>
<span id="5378">5378</span>
<span id="5379">5379</span>
<span id="5380">5380</span>
<span id="5381">5381</span>
<span id="5382">5382</span>
<span id="5383">5383</span>
<span id="5384">5384</span>
<span id="5385">5385</span>
<span id="5386">5386</span>
<span id="5387">5387</span>
<span id="5388">5388</span>
<span id="5389">5389</span>
<span id="5390">5390</span>
<span id="5391">5391</span>
<span id="5392">5392</span>
<span id="5393">5393</span>
<span id="5394">5394</span>
<span id="5395">5395</span>
<span id="5396">5396</span>
<span id="5397">5397</span>
<span id="5398">5398</span>
<span id="5399">5399</span>
<span id="5400">5400</span>
<span id="5401">5401</span>
<span id="5402">5402</span>
<span id="5403">5403</span>
<span id="5404">5404</span>
<span id="5405">5405</span>
<span id="5406">5406</span>
<span id="5407">5407</span>
<span id="5408">5408</span>
<span id="5409">5409</span>
<span id="5410">5410</span>
<span id="5411">5411</span>
<span id="5412">5412</span>
<span id="5413">5413</span>
<span id="5414">5414</span>
<span id="5415">5415</span>
<span id="5416">5416</span>
<span id="5417">5417</span>
<span id="5418">5418</span>
<span id="5419">5419</span>
<span id="5420">5420</span>
<span id="5421">5421</span>
<span id="5422">5422</span>
<span id="5423">5423</span>
<span id="5424">5424</span>
<span id="5425">5425</span>
<span id="5426">5426</span>
<span id="5427">5427</span>
<span id="5428">5428</span>
<span id="5429">5429</span>
<span id="5430">5430</span>
<span id="5431">5431</span>
<span id="5432">5432</span>
<span id="5433">5433</span>
<span id="5434">5434</span>
<span id="5435">5435</span>
<span id="5436">5436</span>
<span id="5437">5437</span>
<span id="5438">5438</span>
<span id="5439">5439</span>
<span id="5440">5440</span>
<span id="5441">5441</span>
<span id="5442">5442</span>
<span id="5443">5443</span>
<span id="5444">5444</span>
<span id="5445">5445</span>
<span id="5446">5446</span>
<span id="5447">5447</span>
<span id="5448">5448</span>
<span id="5449">5449</span>
<span id="5450">5450</span>
<span id="5451">5451</span>
<span id="5452">5452</span>
<span id="5453">5453</span>
<span id="5454">5454</span>
<span id="5455">5455</span>
<span id="5456">5456</span>
<span id="5457">5457</span>
<span id="5458">5458</span>
<span id="5459">5459</span>
<span id="5460">5460</span>
<span id="5461">5461</span>
<span id="5462">5462</span>
<span id="5463">5463</span>
<span id="5464">5464</span>
<span id="5465">5465</span>
<span id="5466">5466</span>
<span id="5467">5467</span>
<span id="5468">5468</span>
<span id="5469">5469</span>
<span id="5470">5470</span>
<span id="5471">5471</span>
<span id="5472">5472</span>
<span id="5473">5473</span>
<span id="5474">5474</span>
<span id="5475">5475</span>
<span id="5476">5476</span>
<span id="5477">5477</span>
<span id="5478">5478</span>
<span id="5479">5479</span>
<span id="5480">5480</span>
<span id="5481">5481</span>
<span id="5482">5482</span>
<span id="5483">5483</span>
<span id="5484">5484</span>
<span id="5485">5485</span>
<span id="5486">5486</span>
<span id="5487">5487</span>
<span id="5488">5488</span>
<span id="5489">5489</span>
<span id="5490">5490</span>
<span id="5491">5491</span>
<span id="5492">5492</span>
<span id="5493">5493</span>
<span id="5494">5494</span>
<span id="5495">5495</span>
<span id="5496">5496</span>
<span id="5497">5497</span>
<span id="5498">5498</span>
<span id="5499">5499</span>
<span id="5500">5500</span>
<span id="5501">5501</span>
<span id="5502">5502</span>
<span id="5503">5503</span>
<span id="5504">5504</span>
<span id="5505">5505</span>
<span id="5506">5506</span>
<span id="5507">5507</span>
<span id="5508">5508</span>
<span id="5509">5509</span>
<span id="5510">5510</span>
<span id="5511">5511</span>
<span id="5512">5512</span>
<span id="5513">5513</span>
<span id="5514">5514</span>
<span id="5515">5515</span>
<span id="5516">5516</span>
<span id="5517">5517</span>
<span id="5518">5518</span>
<span id="5519">5519</span>
<span id="5520">5520</span>
<span id="5521">5521</span>
<span id="5522">5522</span>
<span id="5523">5523</span>
<span id="5524">5524</span>
<span id="5525">5525</span>
<span id="5526">5526</span>
<span id="5527">5527</span>
<span id="5528">5528</span>
<span id="5529">5529</span>
<span id="5530">5530</span>
<span id="5531">5531</span>
<span id="5532">5532</span>
<span id="5533">5533</span>
<span id="5534">5534</span>
<span id="5535">5535</span>
<span id="5536">5536</span>
<span id="5537">5537</span>
<span id="5538">5538</span>
<span id="5539">5539</span>
<span id="5540">5540</span>
<span id="5541">5541</span>
<span id="5542">5542</span>
<span id="5543">5543</span>
<span id="5544">5544</span>
<span id="5545">5545</span>
<span id="5546">5546</span>
<span id="5547">5547</span>
<span id="5548">5548</span>
<span id="5549">5549</span>
<span id="5550">5550</span>
<span id="5551">5551</span>
<span id="5552">5552</span>
<span id="5553">5553</span>
<span id="5554">5554</span>
<span id="5555">5555</span>
<span id="5556">5556</span>
<span id="5557">5557</span>
<span id="5558">5558</span>
<span id="5559">5559</span>
<span id="5560">5560</span>
<span id="5561">5561</span>
<span id="5562">5562</span>
<span id="5563">5563</span>
<span id="5564">5564</span>
<span id="5565">5565</span>
<span id="5566">5566</span>
<span id="5567">5567</span>
<span id="5568">5568</span>
<span id="5569">5569</span>
<span id="5570">5570</span>
<span id="5571">5571</span>
<span id="5572">5572</span>
<span id="5573">5573</span>
<span id="5574">5574</span>
<span id="5575">5575</span>
<span id="5576">5576</span>
<span id="5577">5577</span>
<span id="5578">5578</span>
<span id="5579">5579</span>
<span id="5580">5580</span>
<span id="5581">5581</span>
<span id="5582">5582</span>
<span id="5583">5583</span>
<span id="5584">5584</span>
<span id="5585">5585</span>
<span id="5586">5586</span>
<span id="5587">5587</span>
<span id="5588">5588</span>
<span id="5589">5589</span>
<span id="5590">5590</span>
<span id="5591">5591</span>
<span id="5592">5592</span>
<span id="5593">5593</span>
<span id="5594">5594</span>
<span id="5595">5595</span>
<span id="5596">5596</span>
<span id="5597">5597</span>
<span id="5598">5598</span>
<span id="5599">5599</span>
<span id="5600">5600</span>
<span id="5601">5601</span>
<span id="5602">5602</span>
<span id="5603">5603</span>
<span id="5604">5604</span>
<span id="5605">5605</span>
<span id="5606">5606</span>
<span id="5607">5607</span>
<span id="5608">5608</span>
<span id="5609">5609</span>
<span id="5610">5610</span>
<span id="5611">5611</span>
<span id="5612">5612</span>
<span id="5613">5613</span>
<span id="5614">5614</span>
<span id="5615">5615</span>
<span id="5616">5616</span>
<span id="5617">5617</span>
<span id="5618">5618</span>
<span id="5619">5619</span>
<span id="5620">5620</span>
<span id="5621">5621</span>
<span id="5622">5622</span>
<span id="5623">5623</span>
<span id="5624">5624</span>
<span id="5625">5625</span>
<span id="5626">5626</span>
<span id="5627">5627</span>
<span id="5628">5628</span>
<span id="5629">5629</span>
<span id="5630">5630</span>
<span id="5631">5631</span>
<span id="5632">5632</span>
<span id="5633">5633</span>
<span id="5634">5634</span>
<span id="5635">5635</span>
<span id="5636">5636</span>
<span id="5637">5637</span>
<span id="5638">5638</span>
<span id="5639">5639</span>
<span id="5640">5640</span>
<span id="5641">5641</span>
<span id="5642">5642</span>
<span id="5643">5643</span>
<span id="5644">5644</span>
<span id="5645">5645</span>
<span id="5646">5646</span>
<span id="5647">5647</span>
<span id="5648">5648</span>
<span id="5649">5649</span>
<span id="5650">5650</span>
<span id="5651">5651</span>
<span id="5652">5652</span>
<span id="5653">5653</span>
<span id="5654">5654</span>
<span id="5655">5655</span>
<span id="5656">5656</span>
<span id="5657">5657</span>
<span id="5658">5658</span>
<span id="5659">5659</span>
<span id="5660">5660</span>
<span id="5661">5661</span>
<span id="5662">5662</span>
<span id="5663">5663</span>
</pre><pre class="rust"><code><span class="doccomment">//! A library to parse the x86 CPUID instruction, written in rust with no
//! external dependencies. The implementation closely resembles the Intel CPUID
//! manual description. The library works with no_std.
//!
//! ## Example
//! ```rust
//! use raw_cpuid::CpuId;
//! let cpuid = CpuId::new();
//!
//! if let Some(vf) = cpuid.get_vendor_info() {
//! assert!(vf.as_str() == &quot;GenuineIntel&quot; || vf.as_str() == &quot;AuthenticAMD&quot;);
//! }
//!
//! let has_sse = cpuid.get_feature_info().map_or(false, |finfo| finfo.has_sse());
//! if has_sse {
//! println!(&quot;CPU supports SSE!&quot;);
//! }
//!
//! if let Some(cparams) = cpuid.get_cache_parameters() {
//! for cache in cparams {
//! let size = cache.associativity() * cache.physical_line_partitions() * cache.coherency_line_size() * cache.sets();
//! println!(&quot;L{}-Cache size is {}&quot;, cache.level(), size);
//! }
//! } else {
//! println!(&quot;No cache parameter information available&quot;)
//! }
//! ```
//!
//! # Platform support
//!
//! CPU vendors may choose to not support certain functions/leafs in cpuid or
//! only support them partially. We highlight this with the following emojis
//! throughout the documentation:
//!
//! - ✅: This struct/function is fully supported by the vendor.
//! - 🟡: This struct is partially supported by the vendor, refer to individual
//! functions for more information.
//! - ❌: This struct/function is not supported by the vendor. When queried on
//! this platform, we will return None/false/0 (or some other sane default).
//! - ❓: This struct/function is not supported by the vendor according to the
//! manual, but the in practice it still may return valid information.
//!
//! Note that the presence of a ✅ does not guarantee that a specific feature
//! will exist for your CPU -- just that it is potentially supported by the
//! vendor on some of its chips. You will still have to query it at runtime.
</span><span class="attribute">#![cfg_attr(not(feature = <span class="string">&quot;std&quot;</span>), no_std)]
#![crate_name = <span class="string">&quot;raw_cpuid&quot;</span>]
#![crate_type = <span class="string">&quot;lib&quot;</span>]
#[cfg(test)]
#[macro_use]
</span><span class="kw">extern crate </span>std;
<span class="attribute">#[cfg(feature = <span class="string">&quot;display&quot;</span>)]
</span><span class="kw">pub mod </span>display;
<span class="kw">mod </span>extended;
<span class="attribute">#[cfg(test)]
</span><span class="kw">mod </span>tests;
<span class="attribute">#[cfg(feature = <span class="string">&quot;serialize&quot;</span>)]
#[macro_use]
</span><span class="kw">extern crate </span>serde_derive;
<span class="attribute">#[cfg(feature = <span class="string">&quot;serialize&quot;</span>)]
</span><span class="kw">extern crate </span>serde;
<span class="attribute">#[macro_use]
</span><span class="kw">extern crate </span>bitflags;
<span class="attribute">#[cfg(all(
feature = <span class="string">&quot;serialize&quot;</span>,
not(any(
all(target_arch = <span class="string">&quot;x86&quot;</span>, not(target_env = <span class="string">&quot;sgx&quot;</span>), target_feature = <span class="string">&quot;sse&quot;</span>),
all(target_arch = <span class="string">&quot;x86_64&quot;</span>, not(target_env = <span class="string">&quot;sgx&quot;</span>))
))
))]
</span><span class="macro">core::compile_error!</span>(<span class="string">&quot;Feature `serialize` is not supported on targets that do not have native cpuid. x86 and x86_64 targets with SGX and x86 targets without SSE are consider to not have native cpuid.&quot;</span>);
<span class="doccomment">/// Uses Rust&#39;s `cpuid` function from the `arch` module.
</span><span class="attribute">#[cfg(any(
all(target_arch = <span class="string">&quot;x86&quot;</span>, not(target_env = <span class="string">&quot;sgx&quot;</span>), target_feature = <span class="string">&quot;sse&quot;</span>),
all(target_arch = <span class="string">&quot;x86_64&quot;</span>, not(target_env = <span class="string">&quot;sgx&quot;</span>))
))]
</span><span class="kw">pub mod </span>native_cpuid {
<span class="kw">use </span><span class="kw">crate</span>::CpuIdResult;
<span class="attribute">#[cfg(all(target_arch = <span class="string">&quot;x86&quot;</span>, not(target_env = <span class="string">&quot;sgx&quot;</span>), target_feature = <span class="string">&quot;sse&quot;</span>))]
</span><span class="kw">use </span>core::arch::x86 <span class="kw">as </span>arch;
<span class="attribute">#[cfg(all(target_arch = <span class="string">&quot;x86_64&quot;</span>, not(target_env = <span class="string">&quot;sgx&quot;</span>)))]
</span><span class="kw">use </span>core::arch::x86_64 <span class="kw">as </span>arch;
<span class="kw">pub fn </span>cpuid_count(a: u32, c: u32) -&gt; CpuIdResult {
<span class="comment">// Safety: CPUID is supported on all x86_64 CPUs and all x86 CPUs with
// SSE, but not by SGX.
</span><span class="kw">let </span>result = <span class="kw">unsafe </span>{ <span class="self">self</span>::arch::__cpuid_count(a, c) };
CpuIdResult {
eax: result.eax,
ebx: result.ebx,
ecx: result.ecx,
edx: result.edx,
}
}
}
<span class="kw">use </span>core::fmt::{<span class="self">self</span>, Debug, Formatter};
<span class="kw">use </span>core::mem::size_of;
<span class="kw">use </span>core::slice;
<span class="kw">use </span>core::str;
<span class="kw">pub use </span>extended::<span class="kw-2">*</span>;
<span class="attribute">#[cfg(not(test))]
</span><span class="kw">mod </span>std {
<span class="kw">pub use </span>core::ops;
<span class="kw">pub use </span>core::option;
}
<span class="doccomment">/// Macro which queries cpuid directly.
///
/// First parameter is cpuid leaf (EAX register value),
/// second optional parameter is the subleaf (ECX register value).
</span><span class="attribute">#[cfg(any(
all(target_arch = <span class="string">&quot;x86&quot;</span>, not(target_env = <span class="string">&quot;sgx&quot;</span>), target_feature = <span class="string">&quot;sse&quot;</span>),
all(target_arch = <span class="string">&quot;x86_64&quot;</span>, not(target_env = <span class="string">&quot;sgx&quot;</span>))
))]
#[macro_export]
</span><span class="macro">macro_rules! </span>cpuid {
(<span class="macro-nonterminal">$eax</span>:expr) =&gt; {
<span class="macro-nonterminal">$crate::native_cpuid::cpuid_count</span>(<span class="macro-nonterminal">$eax </span><span class="kw">as </span>u32, <span class="number">0</span>)
};
(<span class="macro-nonterminal">$eax</span>:expr, <span class="macro-nonterminal">$ecx</span>:expr) =&gt; {
<span class="macro-nonterminal">$crate::native_cpuid::cpuid_count</span>(<span class="macro-nonterminal">$eax </span><span class="kw">as </span>u32, <span class="macro-nonterminal">$ecx </span><span class="kw">as </span>u32)
};
}
<span class="kw">fn </span>get_bits(r: u32, from: u32, to: u32) -&gt; u32 {
<span class="macro">assert!</span>(from &lt;= <span class="number">31</span>);
<span class="macro">assert!</span>(to &lt;= <span class="number">31</span>);
<span class="macro">assert!</span>(from &lt;= to);
<span class="kw">let </span>mask = <span class="kw">match </span>to {
<span class="number">31 </span>=&gt; <span class="number">0xffffffff</span>,
<span class="kw">_ </span>=&gt; (<span class="number">1 </span>&lt;&lt; (to + <span class="number">1</span>)) - <span class="number">1</span>,
};
(r &amp; mask) &gt;&gt; from
}
<span class="macro">macro_rules! </span>check_flag {
(<span class="macro-nonterminal">$doc</span>:meta, <span class="macro-nonterminal">$fun</span>:ident, <span class="macro-nonterminal">$flags</span>:ident, <span class="macro-nonterminal">$flag</span>:expr) =&gt; {
<span class="attribute">#[<span class="macro-nonterminal">$doc</span>]
</span><span class="kw">pub fn </span><span class="macro-nonterminal">$fun</span>(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.<span class="macro-nonterminal">$flags</span>.contains(<span class="macro-nonterminal">$flag</span>)
}
};
}
<span class="macro">macro_rules! </span>is_bit_set {
(<span class="macro-nonterminal">$field</span>:expr, <span class="macro-nonterminal">$bit</span>:expr) =&gt; {
<span class="macro-nonterminal">$field </span>&amp; (<span class="number">1 </span>&lt;&lt; <span class="macro-nonterminal">$bit</span>) &gt; <span class="number">0
</span>};
}
<span class="macro">macro_rules! </span>check_bit_fn {
(<span class="macro-nonterminal">$doc</span>:meta, <span class="macro-nonterminal">$fun</span>:ident, <span class="macro-nonterminal">$field</span>:ident, <span class="macro-nonterminal">$bit</span>:expr) =&gt; {
<span class="attribute">#[<span class="macro-nonterminal">$doc</span>]
</span><span class="kw">pub fn </span><span class="macro-nonterminal">$fun</span>(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="macro">is_bit_set!</span>(<span class="self">self</span>.<span class="macro-nonterminal">$field</span>, <span class="macro-nonterminal">$bit</span>)
}
};
}
<span class="doccomment">/// Implements function to read/write cpuid.
/// This allows to conveniently swap out the underlying cpuid implementation
/// with one that returns data that is deterministic (for unit-testing).
</span><span class="attribute">#[derive(Debug, Clone, Copy)]
</span><span class="kw">struct </span>CpuIdReader {
cpuid_fn: <span class="kw">fn</span>(u32, u32) -&gt; CpuIdResult,
}
<span class="kw">impl </span>CpuIdReader {
<span class="kw">fn </span>new(cpuid_fn: <span class="kw">fn</span>(u32, u32) -&gt; CpuIdResult) -&gt; <span class="self">Self </span>{
<span class="self">Self </span>{ cpuid_fn }
}
<span class="kw">fn </span>cpuid1(<span class="kw-2">&amp;</span><span class="self">self</span>, eax: u32) -&gt; CpuIdResult {
(<span class="self">self</span>.cpuid_fn)(eax, <span class="number">0</span>)
}
<span class="kw">fn </span>cpuid2(<span class="kw-2">&amp;</span><span class="self">self</span>, eax: u32, ecx: u32) -&gt; CpuIdResult {
(<span class="self">self</span>.cpuid_fn)(eax, ecx)
}
}
<span class="attribute">#[cfg(any(
all(target_arch = <span class="string">&quot;x86&quot;</span>, not(target_env = <span class="string">&quot;sgx&quot;</span>), target_feature = <span class="string">&quot;sse&quot;</span>),
all(target_arch = <span class="string">&quot;x86_64&quot;</span>, not(target_env = <span class="string">&quot;sgx&quot;</span>))
))]
</span><span class="kw">impl </span>Default <span class="kw">for </span>CpuIdReader {
<span class="kw">fn </span>default() -&gt; <span class="self">Self </span>{
<span class="self">Self </span>{
cpuid_fn: native_cpuid::cpuid_count,
}
}
}
<span class="attribute">#[derive(Debug, Eq, PartialEq, Clone, Copy)]
#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, derive(Serialize, Deserialize))]
</span><span class="kw">enum </span>Vendor {
Intel,
Amd,
Unknown(u32, u32, u32),
}
<span class="kw">impl </span>Vendor {
<span class="kw">fn </span>from_vendor_leaf(res: CpuIdResult) -&gt; <span class="self">Self </span>{
<span class="kw">let </span>vi = VendorInfo {
ebx: res.ebx,
ecx: res.ecx,
edx: res.edx,
};
<span class="kw">match </span>vi.as_str() {
<span class="string">&quot;GenuineIntel&quot; </span>=&gt; Vendor::Intel,
<span class="string">&quot;AuthenticAMD&quot; </span>=&gt; Vendor::Amd,
<span class="kw">_ </span>=&gt; Vendor::Unknown(res.ebx, res.ecx, res.edx),
}
}
}
<span class="doccomment">/// The main type used to query information about the CPU we&#39;re running on.
///
/// Other structs can be accessed by going through this type.
</span><span class="attribute">#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, derive(Serialize, Deserialize))]
#[derive(Clone, Copy)]
</span><span class="kw">pub struct </span>CpuId {
<span class="attribute">#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, serde(skip))]
</span>read: CpuIdReader,
<span class="doccomment">/// CPU vendor to differntiate cases where logic needs to differ in code .
</span>vendor: Vendor,
<span class="doccomment">/// How many basic leafs are supported (EAX &lt; EAX_HYPERVISOR_INFO)
</span>supported_leafs: u32,
<span class="doccomment">/// How many extended leafs are supported (e.g., leafs with EAX &gt; EAX_EXTENDED_FUNCTION_INFO)
</span>supported_extended_leafs: u32,
}
<span class="attribute">#[cfg(any(
all(target_arch = <span class="string">&quot;x86&quot;</span>, not(target_env = <span class="string">&quot;sgx&quot;</span>), target_feature = <span class="string">&quot;sse&quot;</span>),
all(target_arch = <span class="string">&quot;x86_64&quot;</span>, not(target_env = <span class="string">&quot;sgx&quot;</span>))
))]
</span><span class="kw">impl </span>Default <span class="kw">for </span>CpuId {
<span class="kw">fn </span>default() -&gt; CpuId {
CpuId::with_cpuid_fn(native_cpuid::cpuid_count)
}
}
<span class="doccomment">/// Low-level data-structure to store result of cpuid instruction.
</span><span class="attribute">#[derive(Copy, Clone, Eq, PartialEq)]
#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, derive(Serialize, Deserialize))]
#[repr(C)]
</span><span class="kw">pub struct </span>CpuIdResult {
<span class="doccomment">/// Return value EAX register
</span><span class="kw">pub </span>eax: u32,
<span class="doccomment">/// Return value EBX register
</span><span class="kw">pub </span>ebx: u32,
<span class="doccomment">/// Return value ECX register
</span><span class="kw">pub </span>ecx: u32,
<span class="doccomment">/// Return value EDX register
</span><span class="kw">pub </span>edx: u32,
}
<span class="kw">impl </span>CpuIdResult {
<span class="kw">pub fn </span>all_zero(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.eax == <span class="number">0 </span>&amp;&amp; <span class="self">self</span>.ebx == <span class="number">0 </span>&amp;&amp; <span class="self">self</span>.ecx == <span class="number">0 </span>&amp;&amp; <span class="self">self</span>.edx == <span class="number">0
</span>}
}
<span class="kw">impl </span>Debug <span class="kw">for </span>CpuIdResult {
<span class="kw">fn </span>fmt(<span class="kw-2">&amp;</span><span class="self">self</span>, f: <span class="kw-2">&amp;mut </span>Formatter&lt;<span class="lifetime">&#39;_</span>&gt;) -&gt; core::fmt::Result {
f.debug_struct(<span class="string">&quot;CpuIdResult&quot;</span>)
.field(<span class="string">&quot;eax&quot;</span>, <span class="kw-2">&amp;</span>(<span class="self">self</span>.eax <span class="kw">as </span><span class="kw-2">*const </span>u32))
.field(<span class="string">&quot;ebx&quot;</span>, <span class="kw-2">&amp;</span>(<span class="self">self</span>.ebx <span class="kw">as </span><span class="kw-2">*const </span>u32))
.field(<span class="string">&quot;ecx&quot;</span>, <span class="kw-2">&amp;</span>(<span class="self">self</span>.ecx <span class="kw">as </span><span class="kw-2">*const </span>u32))
.field(<span class="string">&quot;edx&quot;</span>, <span class="kw-2">&amp;</span>(<span class="self">self</span>.edx <span class="kw">as </span><span class="kw-2">*const </span>u32))
.finish()
}
}
<span class="comment">//
// Normal leafs:
//
</span><span class="kw">const </span>EAX_VENDOR_INFO: u32 = <span class="number">0x0</span>;
<span class="kw">const </span>EAX_FEATURE_INFO: u32 = <span class="number">0x1</span>;
<span class="kw">const </span>EAX_CACHE_INFO: u32 = <span class="number">0x2</span>;
<span class="kw">const </span>EAX_PROCESSOR_SERIAL: u32 = <span class="number">0x3</span>;
<span class="kw">const </span>EAX_CACHE_PARAMETERS: u32 = <span class="number">0x4</span>;
<span class="kw">const </span>EAX_MONITOR_MWAIT_INFO: u32 = <span class="number">0x5</span>;
<span class="kw">const </span>EAX_THERMAL_POWER_INFO: u32 = <span class="number">0x6</span>;
<span class="kw">const </span>EAX_STRUCTURED_EXTENDED_FEATURE_INFO: u32 = <span class="number">0x7</span>;
<span class="kw">const </span>EAX_DIRECT_CACHE_ACCESS_INFO: u32 = <span class="number">0x9</span>;
<span class="kw">const </span>EAX_PERFORMANCE_MONITOR_INFO: u32 = <span class="number">0xA</span>;
<span class="kw">const </span>EAX_EXTENDED_TOPOLOGY_INFO: u32 = <span class="number">0xB</span>;
<span class="kw">const </span>EAX_EXTENDED_STATE_INFO: u32 = <span class="number">0xD</span>;
<span class="kw">const </span>EAX_RDT_MONITORING: u32 = <span class="number">0xF</span>;
<span class="kw">const </span>EAX_RDT_ALLOCATION: u32 = <span class="number">0x10</span>;
<span class="kw">const </span>EAX_SGX: u32 = <span class="number">0x12</span>;
<span class="kw">const </span>EAX_TRACE_INFO: u32 = <span class="number">0x14</span>;
<span class="kw">const </span>EAX_TIME_STAMP_COUNTER_INFO: u32 = <span class="number">0x15</span>;
<span class="kw">const </span>EAX_FREQUENCY_INFO: u32 = <span class="number">0x16</span>;
<span class="kw">const </span>EAX_SOC_VENDOR_INFO: u32 = <span class="number">0x17</span>;
<span class="kw">const </span>EAX_DETERMINISTIC_ADDRESS_TRANSLATION_INFO: u32 = <span class="number">0x18</span>;
<span class="kw">const </span>EAX_EXTENDED_TOPOLOGY_INFO_V2: u32 = <span class="number">0x1F</span>;
<span class="doccomment">/// Hypervisor leaf
</span><span class="kw">const </span>EAX_HYPERVISOR_INFO: u32 = <span class="number">0x4000_0000</span>;
<span class="comment">//
// Extended leafs:
//
</span><span class="kw">const </span>EAX_EXTENDED_FUNCTION_INFO: u32 = <span class="number">0x8000_0000</span>;
<span class="kw">const </span>EAX_EXTENDED_PROCESSOR_AND_FEATURE_IDENTIFIERS: u32 = <span class="number">0x8000_0001</span>;
<span class="kw">const </span>EAX_EXTENDED_BRAND_STRING: u32 = <span class="number">0x8000_0002</span>;
<span class="kw">const </span>EAX_L1_CACHE_INFO: u32 = <span class="number">0x8000_0005</span>;
<span class="kw">const </span>EAX_L2_L3_CACHE_INFO: u32 = <span class="number">0x8000_0006</span>;
<span class="kw">const </span>EAX_ADVANCED_POWER_MGMT_INFO: u32 = <span class="number">0x8000_0007</span>;
<span class="kw">const </span>EAX_PROCESSOR_CAPACITY_INFO: u32 = <span class="number">0x8000_0008</span>;
<span class="kw">const </span>EAX_TLB_1GB_PAGE_INFO: u32 = <span class="number">0x8000_0019</span>;
<span class="kw">const </span>EAX_PERFORMANCE_OPTIMIZATION_INFO: u32 = <span class="number">0x8000_001A</span>;
<span class="kw">const </span>EAX_CACHE_PARAMETERS_AMD: u32 = <span class="number">0x8000_001D</span>;
<span class="kw">const </span>EAX_PROCESSOR_TOPOLOGY_INFO: u32 = <span class="number">0x8000_001E</span>;
<span class="kw">const </span>EAX_MEMORY_ENCRYPTION_INFO: u32 = <span class="number">0x8000_001F</span>;
<span class="kw">const </span>EAX_SVM_FEATURES: u32 = <span class="number">0x8000_000A</span>;
<span class="kw">impl </span>CpuId {
<span class="doccomment">/// Return new CpuId struct.
</span><span class="attribute">#[cfg(any(
all(target_arch = <span class="string">&quot;x86&quot;</span>, not(target_env = <span class="string">&quot;sgx&quot;</span>), target_feature = <span class="string">&quot;sse&quot;</span>),
all(target_arch = <span class="string">&quot;x86_64&quot;</span>, not(target_env = <span class="string">&quot;sgx&quot;</span>))
))]
</span><span class="kw">pub fn </span>new() -&gt; <span class="self">Self </span>{
<span class="self">Self</span>::default()
}
<span class="doccomment">/// Return new CpuId struct with custom reader function.
///
/// This is useful for example when testing code or if we want to interpose
/// on the CPUID calls this library makes.
</span><span class="kw">pub fn </span>with_cpuid_fn(cpuid_fn: <span class="kw">fn</span>(u32, u32) -&gt; CpuIdResult) -&gt; <span class="self">Self </span>{
<span class="kw">let </span>read = CpuIdReader::new(cpuid_fn);
<span class="kw">let </span>vendor_leaf = read.cpuid1(EAX_VENDOR_INFO);
<span class="kw">let </span>extended_leaf = read.cpuid1(EAX_EXTENDED_FUNCTION_INFO);
CpuId {
supported_leafs: vendor_leaf.eax,
supported_extended_leafs: extended_leaf.eax,
vendor: Vendor::from_vendor_leaf(vendor_leaf),
read,
}
}
<span class="doccomment">/// Check if a non extended leaf (`val`) is supported.
</span><span class="kw">fn </span>leaf_is_supported(<span class="kw-2">&amp;</span><span class="self">self</span>, val: u32) -&gt; bool {
<span class="comment">// Exclude reserved functions/leafs on AMD
</span><span class="kw">if </span><span class="self">self</span>.vendor == Vendor::Amd &amp;&amp; ((<span class="number">0x2</span>..=<span class="number">0x4</span>).contains(<span class="kw-2">&amp;</span>val) || (<span class="number">0x8</span>..=<span class="number">0xa</span>).contains(<span class="kw-2">&amp;</span>val))
{
<span class="kw">return </span><span class="bool-val">false</span>;
}
<span class="kw">if </span>val &lt; EAX_EXTENDED_FUNCTION_INFO {
val &lt;= <span class="self">self</span>.supported_leafs
} <span class="kw">else </span>{
val &lt;= <span class="self">self</span>.supported_extended_leafs
}
}
<span class="doccomment">/// Return information about the vendor (LEAF=0x00).
///
/// This leaf will contain a ASCII readable string such as &quot;GenuineIntel&quot;
/// for Intel CPUs or &quot;AuthenticAMD&quot; for AMD CPUs.
///
/// # Platforms
/// ✅ AMD ✅ Intel
</span><span class="kw">pub fn </span>get_vendor_info(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;VendorInfo&gt; {
<span class="kw">if </span><span class="self">self</span>.leaf_is_supported(EAX_VENDOR_INFO) {
<span class="kw">let </span>res = <span class="self">self</span>.read.cpuid1(EAX_VENDOR_INFO);
<span class="prelude-val">Some</span>(VendorInfo {
ebx: res.ebx,
ecx: res.ecx,
edx: res.edx,
})
} <span class="kw">else </span>{
<span class="prelude-val">None
</span>}
}
<span class="doccomment">/// Query a set of features that are available on this CPU (LEAF=0x01).
///
/// # Platforms
/// ✅ AMD ✅ Intel
</span><span class="kw">pub fn </span>get_feature_info(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;FeatureInfo&gt; {
<span class="kw">if </span><span class="self">self</span>.leaf_is_supported(EAX_FEATURE_INFO) {
<span class="kw">let </span>res = <span class="self">self</span>.read.cpuid1(EAX_FEATURE_INFO);
<span class="prelude-val">Some</span>(FeatureInfo {
vendor: <span class="self">self</span>.vendor,
eax: res.eax,
ebx: res.ebx,
edx_ecx: FeatureInfoFlags {
bits: (((res.edx <span class="kw">as </span>u64) &lt;&lt; <span class="number">32</span>) | (res.ecx <span class="kw">as </span>u64)),
},
})
} <span class="kw">else </span>{
<span class="prelude-val">None
</span>}
}
<span class="doccomment">/// Query basic information about caches (LEAF=0x02).
///
/// # Platforms
/// ❌ AMD ✅ Intel
</span><span class="kw">pub fn </span>get_cache_info(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;CacheInfoIter&gt; {
<span class="kw">if </span><span class="self">self</span>.leaf_is_supported(EAX_CACHE_INFO) {
<span class="kw">let </span>res = <span class="self">self</span>.read.cpuid1(EAX_CACHE_INFO);
<span class="prelude-val">Some</span>(CacheInfoIter {
current: <span class="number">1</span>,
eax: res.eax,
ebx: res.ebx,
ecx: res.ecx,
edx: res.edx,
})
} <span class="kw">else </span>{
<span class="prelude-val">None
</span>}
}
<span class="doccomment">/// Retrieve serial number of processor (LEAF=0x03).
///
/// # Platforms
/// ❌ AMD ✅ Intel
</span><span class="kw">pub fn </span>get_processor_serial(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;ProcessorSerial&gt; {
<span class="kw">if </span><span class="self">self</span>.leaf_is_supported(EAX_PROCESSOR_SERIAL) {
<span class="comment">// upper 64-96 bits are in res1.eax:
</span><span class="kw">let </span>res1 = <span class="self">self</span>.read.cpuid1(EAX_FEATURE_INFO);
<span class="kw">let </span>res = <span class="self">self</span>.read.cpuid1(EAX_PROCESSOR_SERIAL);
<span class="prelude-val">Some</span>(ProcessorSerial {
ecx: res.ecx,
edx: res.edx,
eax: res1.eax,
})
} <span class="kw">else </span>{
<span class="prelude-val">None
</span>}
}
<span class="doccomment">/// Retrieve more elaborate information about caches (LEAF=0x04 or 0x8000_001D).
///
/// As opposed to [get_cache_info](CpuId::get_cache_info), this will tell us
/// about associativity, set size, line size of each level in the cache
/// hierarchy.
///
/// # Platforms
/// 🟡 AMD ✅ Intel
</span><span class="kw">pub fn </span>get_cache_parameters(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;CacheParametersIter&gt; {
<span class="kw">if </span><span class="self">self</span>.leaf_is_supported(EAX_CACHE_PARAMETERS)
|| (<span class="self">self</span>.vendor == Vendor::Amd &amp;&amp; <span class="self">self</span>.leaf_is_supported(EAX_CACHE_PARAMETERS_AMD))
{
<span class="prelude-val">Some</span>(CacheParametersIter {
read: <span class="self">self</span>.read,
leaf: <span class="kw">if </span><span class="self">self</span>.vendor == Vendor::Amd {
EAX_CACHE_PARAMETERS_AMD
} <span class="kw">else </span>{
EAX_CACHE_PARAMETERS
},
current: <span class="number">0</span>,
})
} <span class="kw">else </span>{
<span class="prelude-val">None
</span>}
}
<span class="doccomment">/// Information about how monitor/mwait works on this CPU (LEAF=0x05).
///
/// # Platforms
/// 🟡 AMD ✅ Intel
</span><span class="kw">pub fn </span>get_monitor_mwait_info(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;MonitorMwaitInfo&gt; {
<span class="kw">if </span><span class="self">self</span>.leaf_is_supported(EAX_MONITOR_MWAIT_INFO) {
<span class="kw">let </span>res = <span class="self">self</span>.read.cpuid1(EAX_MONITOR_MWAIT_INFO);
<span class="prelude-val">Some</span>(MonitorMwaitInfo {
eax: res.eax,
ebx: res.ebx,
ecx: res.ecx,
edx: res.edx,
})
} <span class="kw">else </span>{
<span class="prelude-val">None
</span>}
}
<span class="doccomment">/// Query information about thermal and power management features of the CPU (LEAF=0x06).
///
/// # Platforms
/// 🟡 AMD ✅ Intel
</span><span class="kw">pub fn </span>get_thermal_power_info(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;ThermalPowerInfo&gt; {
<span class="kw">if </span><span class="self">self</span>.leaf_is_supported(EAX_THERMAL_POWER_INFO) {
<span class="kw">let </span>res = <span class="self">self</span>.read.cpuid1(EAX_THERMAL_POWER_INFO);
<span class="prelude-val">Some</span>(ThermalPowerInfo {
eax: ThermalPowerFeaturesEax { bits: res.eax },
ebx: res.ebx,
ecx: ThermalPowerFeaturesEcx { bits: res.ecx },
_edx: res.edx,
})
} <span class="kw">else </span>{
<span class="prelude-val">None
</span>}
}
<span class="doccomment">/// Find out about more features supported by this CPU (LEAF=0x07).
///
/// # Platforms
/// 🟡 AMD ✅ Intel
</span><span class="kw">pub fn </span>get_extended_feature_info(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;ExtendedFeatures&gt; {
<span class="kw">if </span><span class="self">self</span>.leaf_is_supported(EAX_STRUCTURED_EXTENDED_FEATURE_INFO) {
<span class="kw">let </span>res = <span class="self">self</span>.read.cpuid1(EAX_STRUCTURED_EXTENDED_FEATURE_INFO);
<span class="prelude-val">Some</span>(ExtendedFeatures {
_eax: res.eax,
ebx: ExtendedFeaturesEbx { bits: res.ebx },
ecx: ExtendedFeaturesEcx { bits: res.ecx },
_edx: res.edx,
})
} <span class="kw">else </span>{
<span class="prelude-val">None
</span>}
}
<span class="doccomment">/// Direct cache access info (LEAF=0x09).
///
/// # Platforms
/// ❌ AMD ✅ Intel
</span><span class="kw">pub fn </span>get_direct_cache_access_info(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;DirectCacheAccessInfo&gt; {
<span class="kw">if </span><span class="self">self</span>.leaf_is_supported(EAX_DIRECT_CACHE_ACCESS_INFO) {
<span class="kw">let </span>res = <span class="self">self</span>.read.cpuid1(EAX_DIRECT_CACHE_ACCESS_INFO);
<span class="prelude-val">Some</span>(DirectCacheAccessInfo { eax: res.eax })
} <span class="kw">else </span>{
<span class="prelude-val">None
</span>}
}
<span class="doccomment">/// Info about performance monitoring (LEAF=0x0A).
///
/// # Platforms
/// ❌ AMD ✅ Intel
</span><span class="kw">pub fn </span>get_performance_monitoring_info(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;PerformanceMonitoringInfo&gt; {
<span class="kw">if </span><span class="self">self</span>.leaf_is_supported(EAX_PERFORMANCE_MONITOR_INFO) {
<span class="kw">let </span>res = <span class="self">self</span>.read.cpuid1(EAX_PERFORMANCE_MONITOR_INFO);
<span class="prelude-val">Some</span>(PerformanceMonitoringInfo {
eax: res.eax,
ebx: PerformanceMonitoringFeaturesEbx { bits: res.ebx },
_ecx: res.ecx,
edx: res.edx,
})
} <span class="kw">else </span>{
<span class="prelude-val">None
</span>}
}
<span class="doccomment">/// Information about topology (LEAF=0x0B).
///
/// Intel SDM suggests software should check support for leaf 0x1F
/// ([`CpuId::get_extended_topology_info_v2`]), and if supported, enumerate
/// that leaf instead.
///
/// # Platforms
/// ✅ AMD ✅ Intel
</span><span class="kw">pub fn </span>get_extended_topology_info(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;ExtendedTopologyIter&gt; {
<span class="kw">if </span><span class="self">self</span>.leaf_is_supported(EAX_EXTENDED_TOPOLOGY_INFO) {
<span class="prelude-val">Some</span>(ExtendedTopologyIter {
read: <span class="self">self</span>.read,
level: <span class="number">0</span>,
is_v2: <span class="bool-val">false</span>,
})
} <span class="kw">else </span>{
<span class="prelude-val">None
</span>}
}
<span class="doccomment">/// Extended information about topology (LEAF=0x1F).
///
/// # Platforms
/// ❌ AMD ✅ Intel
</span><span class="kw">pub fn </span>get_extended_topology_info_v2(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;ExtendedTopologyIter&gt; {
<span class="kw">if </span><span class="self">self</span>.leaf_is_supported(EAX_EXTENDED_TOPOLOGY_INFO_V2) {
<span class="prelude-val">Some</span>(ExtendedTopologyIter {
read: <span class="self">self</span>.read,
level: <span class="number">0</span>,
is_v2: <span class="bool-val">true</span>,
})
} <span class="kw">else </span>{
<span class="prelude-val">None
</span>}
}
<span class="doccomment">/// Information for saving/restoring extended register state (LEAF=0x0D).
///
/// # Platforms
/// ✅ AMD ✅ Intel
</span><span class="kw">pub fn </span>get_extended_state_info(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;ExtendedStateInfo&gt; {
<span class="kw">if </span><span class="self">self</span>.leaf_is_supported(EAX_EXTENDED_STATE_INFO) {
<span class="kw">let </span>res = <span class="self">self</span>.read.cpuid2(EAX_EXTENDED_STATE_INFO, <span class="number">0</span>);
<span class="kw">let </span>res1 = <span class="self">self</span>.read.cpuid2(EAX_EXTENDED_STATE_INFO, <span class="number">1</span>);
<span class="prelude-val">Some</span>(ExtendedStateInfo {
read: <span class="self">self</span>.read,
eax: ExtendedStateInfoXCR0Flags { bits: res.eax },
ebx: res.ebx,
ecx: res.ecx,
_edx: res.edx,
eax1: res1.eax,
ebx1: res1.ebx,
ecx1: ExtendedStateInfoXSSFlags { bits: res1.ecx },
_edx1: res1.edx,
})
} <span class="kw">else </span>{
<span class="prelude-val">None
</span>}
}
<span class="doccomment">/// Quality of service monitoring information (LEAF=0x0F).
///
/// # Platforms
/// ❌ AMD ✅ Intel
</span><span class="kw">pub fn </span>get_rdt_monitoring_info(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;RdtMonitoringInfo&gt; {
<span class="kw">let </span>res = <span class="self">self</span>.read.cpuid1(EAX_RDT_MONITORING);
<span class="kw">if </span><span class="self">self</span>.leaf_is_supported(EAX_RDT_MONITORING) {
<span class="prelude-val">Some</span>(RdtMonitoringInfo {
read: <span class="self">self</span>.read,
ebx: res.ebx,
edx: res.edx,
})
} <span class="kw">else </span>{
<span class="prelude-val">None
</span>}
}
<span class="doccomment">/// Quality of service enforcement information (LEAF=0x10).
///
/// # Platforms
/// ❌ AMD ✅ Intel
</span><span class="kw">pub fn </span>get_rdt_allocation_info(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;RdtAllocationInfo&gt; {
<span class="kw">let </span>res = <span class="self">self</span>.read.cpuid1(EAX_RDT_ALLOCATION);
<span class="kw">if </span><span class="self">self</span>.leaf_is_supported(EAX_RDT_ALLOCATION) {
<span class="prelude-val">Some</span>(RdtAllocationInfo {
read: <span class="self">self</span>.read,
ebx: res.ebx,
})
} <span class="kw">else </span>{
<span class="prelude-val">None
</span>}
}
<span class="doccomment">/// Information about secure enclave support (LEAF=0x12).
///
/// # Platforms
/// ❌ AMD ✅ Intel
</span><span class="kw">pub fn </span>get_sgx_info(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;SgxInfo&gt; {
<span class="comment">// Leaf 12H sub-leaf 0 (ECX = 0) is supported if CPUID.(EAX=07H, ECX=0H):EBX[SGX] = 1.
</span><span class="self">self</span>.get_extended_feature_info().and_then(|info| {
<span class="kw">if </span><span class="self">self</span>.leaf_is_supported(EAX_SGX) &amp;&amp; info.has_sgx() {
<span class="kw">let </span>res = <span class="self">self</span>.read.cpuid2(EAX_SGX, <span class="number">0</span>);
<span class="kw">let </span>res1 = <span class="self">self</span>.read.cpuid2(EAX_SGX, <span class="number">1</span>);
<span class="prelude-val">Some</span>(SgxInfo {
read: <span class="self">self</span>.read,
eax: res.eax,
ebx: res.ebx,
_ecx: res.ecx,
edx: res.edx,
eax1: res1.eax,
ebx1: res1.ebx,
ecx1: res1.ecx,
edx1: res1.edx,
})
} <span class="kw">else </span>{
<span class="prelude-val">None
</span>}
})
}
<span class="doccomment">/// Intel Processor Trace Enumeration Information (LEAF=0x14).
///
/// # Platforms
/// ❌ AMD ✅ Intel
</span><span class="kw">pub fn </span>get_processor_trace_info(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;ProcessorTraceInfo&gt; {
<span class="kw">if </span><span class="self">self</span>.leaf_is_supported(EAX_TRACE_INFO) {
<span class="kw">let </span>res = <span class="self">self</span>.read.cpuid2(EAX_TRACE_INFO, <span class="number">0</span>);
<span class="kw">let </span>res1 = <span class="kw">if </span>res.eax &gt;= <span class="number">1 </span>{
<span class="prelude-val">Some</span>(<span class="self">self</span>.read.cpuid2(EAX_TRACE_INFO, <span class="number">1</span>))
} <span class="kw">else </span>{
<span class="prelude-val">None
</span>};
<span class="prelude-val">Some</span>(ProcessorTraceInfo {
_eax: res.eax,
ebx: res.ebx,
ecx: res.ecx,
_edx: res.edx,
leaf1: res1,
})
} <span class="kw">else </span>{
<span class="prelude-val">None
</span>}
}
<span class="doccomment">/// Time Stamp Counter/Core Crystal Clock Information (LEAF=0x15).
///
/// # Platforms
/// ❌ AMD ✅ Intel
</span><span class="kw">pub fn </span>get_tsc_info(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;TscInfo&gt; {
<span class="kw">if </span><span class="self">self</span>.leaf_is_supported(EAX_TIME_STAMP_COUNTER_INFO) {
<span class="kw">let </span>res = <span class="self">self</span>.read.cpuid2(EAX_TIME_STAMP_COUNTER_INFO, <span class="number">0</span>);
<span class="prelude-val">Some</span>(TscInfo {
eax: res.eax,
ebx: res.ebx,
ecx: res.ecx,
})
} <span class="kw">else </span>{
<span class="prelude-val">None
</span>}
}
<span class="doccomment">/// Processor Frequency Information (LEAF=0x16).
///
/// # Platforms
/// ❌ AMD ✅ Intel
</span><span class="kw">pub fn </span>get_processor_frequency_info(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;ProcessorFrequencyInfo&gt; {
<span class="kw">if </span><span class="self">self</span>.leaf_is_supported(EAX_FREQUENCY_INFO) {
<span class="kw">let </span>res = <span class="self">self</span>.read.cpuid1(EAX_FREQUENCY_INFO);
<span class="prelude-val">Some</span>(ProcessorFrequencyInfo {
eax: res.eax,
ebx: res.ebx,
ecx: res.ecx,
})
} <span class="kw">else </span>{
<span class="prelude-val">None
</span>}
}
<span class="doccomment">/// Contains SoC vendor specific information (LEAF=0x17).
///
/// # Platforms
/// ❌ AMD ✅ Intel
</span><span class="kw">pub fn </span>get_soc_vendor_info(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;SoCVendorInfo&gt; {
<span class="kw">if </span><span class="self">self</span>.leaf_is_supported(EAX_SOC_VENDOR_INFO) {
<span class="kw">let </span>res = <span class="self">self</span>.read.cpuid1(EAX_SOC_VENDOR_INFO);
<span class="prelude-val">Some</span>(SoCVendorInfo {
read: <span class="self">self</span>.read,
eax: res.eax,
ebx: res.ebx,
ecx: res.ecx,
edx: res.edx,
})
} <span class="kw">else </span>{
<span class="prelude-val">None
</span>}
}
<span class="doccomment">/// Query deterministic address translation feature (LEAF=0x18).
///
/// # Platforms
/// ❌ AMD ✅ Intel
</span><span class="kw">pub fn </span>get_deterministic_address_translation_info(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;DatIter&gt; {
<span class="kw">if </span><span class="self">self</span>.leaf_is_supported(EAX_DETERMINISTIC_ADDRESS_TRANSLATION_INFO) {
<span class="kw">let </span>res = <span class="self">self
</span>.read
.cpuid2(EAX_DETERMINISTIC_ADDRESS_TRANSLATION_INFO, <span class="number">0</span>);
<span class="prelude-val">Some</span>(DatIter {
read: <span class="self">self</span>.read,
current: <span class="number">0</span>,
count: res.eax,
})
} <span class="kw">else </span>{
<span class="prelude-val">None
</span>}
}
<span class="doccomment">/// Returns information provided by the hypervisor, if running
/// in a virtual environment (LEAF=0x4000_00xx).
///
/// # Platform
/// Needs to be a virtual CPU to be supported.
</span><span class="kw">pub fn </span>get_hypervisor_info(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;HypervisorInfo&gt; {
<span class="comment">// We only fetch HypervisorInfo, if the Hypervisor-Flag is set.
// See https://github.com/gz/rust-cpuid/issues/52
</span><span class="self">self</span>.get_feature_info()
.filter(|fi| fi.has_hypervisor())
.map(|<span class="kw">_</span>| {
<span class="kw">let </span>res = <span class="self">self</span>.read.cpuid1(EAX_HYPERVISOR_INFO);
<span class="kw">if </span>res.eax &gt; <span class="number">0 </span>{
<span class="prelude-val">Some</span>(HypervisorInfo {
read: <span class="self">self</span>.read,
res,
})
} <span class="kw">else </span>{
<span class="prelude-val">None
</span>}
})
.flatten()
}
<span class="doccomment">/// Extended Processor and Processor Feature Identifiers (LEAF=0x8000_0001).
///
/// # Platforms
/// ✅ AMD 🟡 Intel
</span><span class="kw">pub fn </span>get_extended_processor_and_feature_identifiers(
<span class="kw-2">&amp;</span><span class="self">self</span>,
) -&gt; <span class="prelude-ty">Option</span>&lt;ExtendedProcessorFeatureIdentifiers&gt; {
<span class="kw">if </span><span class="self">self</span>.leaf_is_supported(EAX_EXTENDED_PROCESSOR_AND_FEATURE_IDENTIFIERS) {
<span class="prelude-val">Some</span>(ExtendedProcessorFeatureIdentifiers::new(
<span class="self">self</span>.vendor,
<span class="self">self</span>.read
.cpuid1(EAX_EXTENDED_PROCESSOR_AND_FEATURE_IDENTIFIERS),
))
} <span class="kw">else </span>{
<span class="prelude-val">None
</span>}
}
<span class="doccomment">/// Retrieve processor brand string (LEAF=0x8000_000{2..4}).
///
/// # Platforms
/// ✅ AMD ✅ Intel
</span><span class="kw">pub fn </span>get_processor_brand_string(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;ProcessorBrandString&gt; {
<span class="kw">if </span><span class="self">self</span>.leaf_is_supported(EAX_EXTENDED_BRAND_STRING)
&amp;&amp; <span class="self">self</span>.leaf_is_supported(EAX_EXTENDED_BRAND_STRING + <span class="number">1</span>)
&amp;&amp; <span class="self">self</span>.leaf_is_supported(EAX_EXTENDED_BRAND_STRING + <span class="number">2</span>)
{
<span class="prelude-val">Some</span>(ProcessorBrandString::new([
<span class="self">self</span>.read.cpuid1(EAX_EXTENDED_BRAND_STRING),
<span class="self">self</span>.read.cpuid1(EAX_EXTENDED_BRAND_STRING + <span class="number">1</span>),
<span class="self">self</span>.read.cpuid1(EAX_EXTENDED_BRAND_STRING + <span class="number">2</span>),
]))
} <span class="kw">else </span>{
<span class="prelude-val">None
</span>}
}
<span class="doccomment">/// L1 Instruction Cache Information (LEAF=0x8000_0005)
///
/// # Platforms
/// ✅ AMD ❌ Intel (reserved)
</span><span class="kw">pub fn </span>get_l1_cache_and_tlb_info(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;L1CacheTlbInfo&gt; {
<span class="kw">if </span><span class="self">self</span>.vendor == Vendor::Amd &amp;&amp; <span class="self">self</span>.leaf_is_supported(EAX_L1_CACHE_INFO) {
<span class="prelude-val">Some</span>(L1CacheTlbInfo::new(<span class="self">self</span>.read.cpuid1(EAX_L1_CACHE_INFO)))
} <span class="kw">else </span>{
<span class="prelude-val">None
</span>}
}
<span class="doccomment">/// L2/L3 Cache and TLB Information (LEAF=0x8000_0006).
///
/// # Platforms
/// ✅ AMD 🟡 Intel
</span><span class="kw">pub fn </span>get_l2_l3_cache_and_tlb_info(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;L2And3CacheTlbInfo&gt; {
<span class="kw">if </span><span class="self">self</span>.leaf_is_supported(EAX_L2_L3_CACHE_INFO) {
<span class="prelude-val">Some</span>(L2And3CacheTlbInfo::new(
<span class="self">self</span>.read.cpuid1(EAX_L2_L3_CACHE_INFO),
))
} <span class="kw">else </span>{
<span class="prelude-val">None
</span>}
}
<span class="doccomment">/// Advanced Power Management Information (LEAF=0x8000_0007).
///
/// # Platforms
/// ✅ AMD 🟡 Intel
</span><span class="kw">pub fn </span>get_advanced_power_mgmt_info(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;ApmInfo&gt; {
<span class="kw">if </span><span class="self">self</span>.leaf_is_supported(EAX_ADVANCED_POWER_MGMT_INFO) {
<span class="prelude-val">Some</span>(ApmInfo::new(<span class="self">self</span>.read.cpuid1(EAX_ADVANCED_POWER_MGMT_INFO)))
} <span class="kw">else </span>{
<span class="prelude-val">None
</span>}
}
<span class="doccomment">/// Processor Capacity Parameters and Extended Feature Identification (LEAF=0x8000_0008).
///
/// # Platforms
/// ✅ AMD 🟡 Intel
</span><span class="kw">pub fn </span>get_processor_capacity_feature_info(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;ProcessorCapacityAndFeatureInfo&gt; {
<span class="kw">if </span><span class="self">self</span>.leaf_is_supported(EAX_PROCESSOR_CAPACITY_INFO) {
<span class="prelude-val">Some</span>(ProcessorCapacityAndFeatureInfo::new(
<span class="self">self</span>.read.cpuid1(EAX_PROCESSOR_CAPACITY_INFO),
))
} <span class="kw">else </span>{
<span class="prelude-val">None
</span>}
}
<span class="doccomment">/// This function provides information about the SVM features that the processory
/// supports. (LEAF=0x8000_000A)
///
/// If SVM is not supported if [ExtendedProcessorFeatureIdentifiers::has_svm] is
/// false, this function is reserved then.
///
/// # Platforms
/// ✅ AMD ❌ Intel
</span><span class="kw">pub fn </span>get_svm_info(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;SvmFeatures&gt; {
<span class="kw">let </span>has_svm = <span class="self">self
</span>.get_extended_processor_and_feature_identifiers()
.map_or(<span class="bool-val">false</span>, |f| f.has_svm());
<span class="kw">if </span>has_svm &amp;&amp; <span class="self">self</span>.leaf_is_supported(EAX_SVM_FEATURES) {
<span class="prelude-val">Some</span>(SvmFeatures::new(<span class="self">self</span>.read.cpuid1(EAX_SVM_FEATURES)))
} <span class="kw">else </span>{
<span class="prelude-val">None
</span>}
}
<span class="doccomment">/// TLB 1-GiB Pages Information (LEAF=0x8000_0019)
///
/// # Platforms
/// ✅ AMD ❌ Intel
</span><span class="kw">pub fn </span>get_tlb_1gb_page_info(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;Tlb1gbPageInfo&gt; {
<span class="kw">if </span><span class="self">self</span>.leaf_is_supported(EAX_TLB_1GB_PAGE_INFO) {
<span class="prelude-val">Some</span>(Tlb1gbPageInfo::new(<span class="self">self</span>.read.cpuid1(EAX_TLB_1GB_PAGE_INFO)))
} <span class="kw">else </span>{
<span class="prelude-val">None
</span>}
}
<span class="doccomment">/// Informations about performance optimization (LEAF=0x8000_001A)
///
/// # Platforms
/// ✅ AMD ❌ Intel (reserved)
</span><span class="kw">pub fn </span>get_performance_optimization_info(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;PerformanceOptimizationInfo&gt; {
<span class="kw">if </span><span class="self">self</span>.leaf_is_supported(EAX_PERFORMANCE_OPTIMIZATION_INFO) {
<span class="prelude-val">Some</span>(PerformanceOptimizationInfo::new(
<span class="self">self</span>.read.cpuid1(EAX_PERFORMANCE_OPTIMIZATION_INFO),
))
} <span class="kw">else </span>{
<span class="prelude-val">None
</span>}
}
<span class="doccomment">/// Informations about processor topology (LEAF=0x8000_001E)
///
/// # Platforms
/// ✅ AMD ❌ Intel (reserved)
</span><span class="kw">pub fn </span>get_processor_topology_info(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;ProcessorTopologyInfo&gt; {
<span class="kw">if </span><span class="self">self</span>.leaf_is_supported(EAX_PROCESSOR_TOPOLOGY_INFO) {
<span class="prelude-val">Some</span>(ProcessorTopologyInfo::new(
<span class="self">self</span>.read.cpuid1(EAX_PROCESSOR_TOPOLOGY_INFO),
))
} <span class="kw">else </span>{
<span class="prelude-val">None
</span>}
}
<span class="doccomment">/// Informations about memory encryption support (LEAF=0x8000_001F)
///
/// # Platforms
/// ✅ AMD ❌ Intel (reserved)
</span><span class="kw">pub fn </span>get_memory_encryption_info(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;MemoryEncryptionInfo&gt; {
<span class="kw">if </span><span class="self">self</span>.leaf_is_supported(EAX_MEMORY_ENCRYPTION_INFO) {
<span class="prelude-val">Some</span>(MemoryEncryptionInfo::new(
<span class="self">self</span>.read.cpuid1(EAX_MEMORY_ENCRYPTION_INFO),
))
} <span class="kw">else </span>{
<span class="prelude-val">None
</span>}
}
}
<span class="kw">impl </span>Debug <span class="kw">for </span>CpuId {
<span class="kw">fn </span>fmt(<span class="kw-2">&amp;</span><span class="self">self</span>, f: <span class="kw-2">&amp;mut </span>Formatter&lt;<span class="lifetime">&#39;_</span>&gt;) -&gt; core::fmt::Result {
f.debug_struct(<span class="string">&quot;CpuId&quot;</span>)
.field(<span class="string">&quot;vendor&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.vendor)
<span class="comment">// .field(&quot;supported_leafs&quot;, &amp;(self.supported_leafs as *const u32))
// .field(&quot;supported_extended_leafs&quot;, &amp;(self.supported_extended_leafs as *const u32))
</span>.field(<span class="string">&quot;vendor_info&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.get_vendor_info())
.field(<span class="string">&quot;feature_info&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.get_feature_info())
.field(<span class="string">&quot;cache_info&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.get_cache_info())
.field(<span class="string">&quot;processor_serial&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.get_processor_serial())
.field(<span class="string">&quot;cache_parameters&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.get_cache_parameters())
.field(<span class="string">&quot;monitor_mwait_info&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.get_monitor_mwait_info())
.field(<span class="string">&quot;thermal_power_info&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.get_thermal_power_info())
.field(<span class="string">&quot;extended_feature_info&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.get_extended_feature_info())
.field(
<span class="string">&quot;direct_cache_access_info&quot;</span>,
<span class="kw-2">&amp;</span><span class="self">self</span>.get_direct_cache_access_info(),
)
.field(
<span class="string">&quot;performance_monitoring_info&quot;</span>,
<span class="kw-2">&amp;</span><span class="self">self</span>.get_performance_monitoring_info(),
)
.field(<span class="string">&quot;extended_topology_info&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.get_extended_topology_info())
.field(<span class="string">&quot;extended_state_info&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.get_extended_state_info())
.field(<span class="string">&quot;rdt_monitoring_info&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.get_rdt_monitoring_info())
.field(<span class="string">&quot;rdt_allocation_info&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.get_rdt_allocation_info())
.field(<span class="string">&quot;sgx_info&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.get_sgx_info())
.field(<span class="string">&quot;processor_trace_info&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.get_processor_trace_info())
.field(<span class="string">&quot;tsc_info&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.get_tsc_info())
.field(
<span class="string">&quot;processor_frequency_info&quot;</span>,
<span class="kw-2">&amp;</span><span class="self">self</span>.get_processor_frequency_info(),
)
.field(
<span class="string">&quot;deterministic_address_translation_info&quot;</span>,
<span class="kw-2">&amp;</span><span class="self">self</span>.get_deterministic_address_translation_info(),
)
.field(<span class="string">&quot;soc_vendor_info&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.get_soc_vendor_info())
.field(<span class="string">&quot;hypervisor_info&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.get_hypervisor_info())
.field(
<span class="string">&quot;extended_processor_and_feature_identifiers&quot;</span>,
<span class="kw-2">&amp;</span><span class="self">self</span>.get_extended_processor_and_feature_identifiers(),
)
.field(<span class="string">&quot;processor_brand_string&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.get_processor_brand_string())
.field(<span class="string">&quot;l1_cache_and_tlb_info&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.get_l1_cache_and_tlb_info())
.field(
<span class="string">&quot;l2_l3_cache_and_tlb_info&quot;</span>,
<span class="kw-2">&amp;</span><span class="self">self</span>.get_l2_l3_cache_and_tlb_info(),
)
.field(
<span class="string">&quot;advanced_power_mgmt_info&quot;</span>,
<span class="kw-2">&amp;</span><span class="self">self</span>.get_advanced_power_mgmt_info(),
)
.field(
<span class="string">&quot;processor_capacity_feature_info&quot;</span>,
<span class="kw-2">&amp;</span><span class="self">self</span>.get_processor_capacity_feature_info(),
)
.field(<span class="string">&quot;svm_info&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.get_svm_info())
.field(<span class="string">&quot;tlb_1gb_page_info&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.get_tlb_1gb_page_info())
.field(
<span class="string">&quot;performance_optimization_info&quot;</span>,
<span class="kw-2">&amp;</span><span class="self">self</span>.get_performance_optimization_info(),
)
.field(
<span class="string">&quot;processor_topology_info&quot;</span>,
<span class="kw-2">&amp;</span><span class="self">self</span>.get_processor_topology_info(),
)
.field(<span class="string">&quot;memory_encryption_info&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.get_memory_encryption_info())
.finish()
}
}
<span class="doccomment">/// Vendor Info String (LEAF=0x0)
///
/// A string that can be for example &quot;AuthenticAMD&quot; or &quot;GenuineIntel&quot;.
///
/// # Technical Background
///
/// The vendor info is a 12-byte (96 bit) long string stored in `ebx`, `edx` and
/// `ecx` by the corresponding `cpuid` instruction.
///
/// # Platforms
/// ✅ AMD ✅ Intel
</span><span class="attribute">#[derive(PartialEq, Eq)]
#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, derive(Serialize, Deserialize))]
#[repr(C)]
</span><span class="kw">pub struct </span>VendorInfo {
ebx: u32,
edx: u32,
ecx: u32,
}
<span class="kw">impl </span>VendorInfo {
<span class="doccomment">/// Return vendor identification as human readable string.
</span><span class="kw">pub fn </span>as_str(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="kw-2">&amp;</span>str {
<span class="kw">let </span>brand_string_start = <span class="self">self </span><span class="kw">as </span><span class="kw-2">*const </span>VendorInfo <span class="kw">as </span><span class="kw-2">*const </span>u8;
<span class="kw">let </span>slice = <span class="kw">unsafe </span>{
<span class="comment">// Safety: VendorInfo is laid out with repr(C) and exactly
// 12 byte long without any padding.
</span>slice::from_raw_parts(brand_string_start, size_of::&lt;VendorInfo&gt;())
};
str::from_utf8(slice).unwrap_or(<span class="string">&quot;InvalidVendorString&quot;</span>)
}
<span class="attribute">#[deprecated(
since = <span class="string">&quot;10.0.0&quot;</span>,
note = <span class="string">&quot;Use idiomatic function name `as_str` instead&quot;
</span>)]
</span><span class="kw">pub fn </span>as_string(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="kw-2">&amp;</span>str {
<span class="self">self</span>.as_str()
}
}
<span class="kw">impl </span>Debug <span class="kw">for </span>VendorInfo {
<span class="kw">fn </span>fmt(<span class="kw-2">&amp;</span><span class="self">self</span>, f: <span class="kw-2">&amp;mut </span>Formatter&lt;<span class="lifetime">&#39;_</span>&gt;) -&gt; core::fmt::Result {
f.debug_struct(<span class="string">&quot;VendorInfo&quot;</span>)
.field(<span class="string">&quot;brand_string&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.as_str())
.finish()
}
}
<span class="kw">impl </span>fmt::Display <span class="kw">for </span>VendorInfo {
<span class="kw">fn </span>fmt(<span class="kw-2">&amp;</span><span class="self">self</span>, f: <span class="kw-2">&amp;mut </span>fmt::Formatter) -&gt; fmt::Result {
<span class="macro">write!</span>(f, <span class="string">&quot;{}&quot;</span>, <span class="self">self</span>.as_str())
}
}
<span class="doccomment">/// Iterates over cache information (LEAF=0x02).
///
/// This will just return an index into a static table of cache descriptions
/// (see [CACHE_INFO_TABLE](crate::CACHE_INFO_TABLE)).
///
/// # Platforms
/// ❌ AMD ✅ Intel
</span><span class="attribute">#[derive(PartialEq, Eq, Clone)]
#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, derive(Serialize, Deserialize))]
</span><span class="kw">pub struct </span>CacheInfoIter {
current: u32,
eax: u32,
ebx: u32,
ecx: u32,
edx: u32,
}
<span class="kw">impl </span>Iterator <span class="kw">for </span>CacheInfoIter {
<span class="kw">type </span>Item = CacheInfo;
<span class="doccomment">/// Iterate over all cache information.
</span><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;CacheInfo&gt; {
<span class="comment">// Every byte of the 4 register values returned by cpuid
// can contain information about a cache (except the
// very first one).
</span><span class="kw">if </span><span class="self">self</span>.current &gt;= <span class="number">4 </span>* <span class="number">4 </span>{
<span class="kw">return </span><span class="prelude-val">None</span>;
}
<span class="kw">let </span>reg_index = <span class="self">self</span>.current % <span class="number">4</span>;
<span class="kw">let </span>byte_index = <span class="self">self</span>.current / <span class="number">4</span>;
<span class="kw">let </span>reg = <span class="kw">match </span>reg_index {
<span class="number">0 </span>=&gt; <span class="self">self</span>.eax,
<span class="number">1 </span>=&gt; <span class="self">self</span>.ebx,
<span class="number">2 </span>=&gt; <span class="self">self</span>.ecx,
<span class="number">3 </span>=&gt; <span class="self">self</span>.edx,
<span class="kw">_ </span>=&gt; <span class="macro">unreachable!</span>(),
};
<span class="kw">let </span>byte = <span class="kw">match </span>byte_index {
<span class="number">0 </span>=&gt; reg,
<span class="number">1 </span>=&gt; reg &gt;&gt; <span class="number">8</span>,
<span class="number">2 </span>=&gt; reg &gt;&gt; <span class="number">16</span>,
<span class="number">3 </span>=&gt; reg &gt;&gt; <span class="number">24</span>,
<span class="kw">_ </span>=&gt; <span class="macro">unreachable!</span>(),
} <span class="kw">as </span>u8;
<span class="kw">if </span>byte == <span class="number">0 </span>{
<span class="self">self</span>.current += <span class="number">1</span>;
<span class="kw">return </span><span class="self">self</span>.next();
}
<span class="kw">for </span>cache_info <span class="kw">in </span>CACHE_INFO_TABLE.iter() {
<span class="kw">if </span>cache_info.num == byte {
<span class="self">self</span>.current += <span class="number">1</span>;
<span class="kw">return </span><span class="prelude-val">Some</span>(<span class="kw-2">*</span>cache_info);
}
}
<span class="prelude-val">None
</span>}
}
<span class="kw">impl </span>Debug <span class="kw">for </span>CacheInfoIter {
<span class="kw">fn </span>fmt(<span class="kw-2">&amp;</span><span class="self">self</span>, f: <span class="kw-2">&amp;mut </span>Formatter&lt;<span class="lifetime">&#39;_</span>&gt;) -&gt; core::fmt::Result {
<span class="kw">let </span><span class="kw-2">mut </span>debug = f.debug_list();
<span class="self">self</span>.clone().for_each(|<span class="kw-2">ref </span>item| {
debug.entry(item);
});
debug.finish()
}
}
<span class="doccomment">/// What type of cache are we dealing with?
</span><span class="attribute">#[derive(Copy, Clone, Debug)]
#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, derive(Serialize, Deserialize))]
</span><span class="kw">pub enum </span>CacheInfoType {
General,
Cache,
TLB,
STLB,
DTLB,
Prefetch,
}
<span class="doccomment">/// Describes any kind of cache (TLB, Data and Instruction caches plus prefetchers).
</span><span class="attribute">#[derive(Copy, Clone)]
#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, derive(Serialize, Deserialize))]
</span><span class="kw">pub struct </span>CacheInfo {
<span class="doccomment">/// Number as retrieved from cpuid
</span><span class="kw">pub </span>num: u8,
<span class="doccomment">/// Cache type
</span><span class="kw">pub </span>typ: CacheInfoType,
}
<span class="kw">impl </span>CacheInfo {
<span class="doccomment">/// Description of the cache (from Intel Manual)
</span><span class="kw">pub fn </span>desc(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="kw-2">&amp;</span><span class="lifetime">&#39;static </span>str {
<span class="kw">match </span><span class="self">self</span>.num {
<span class="number">0x00 </span>=&gt; <span class="string">&quot;Null descriptor, this byte contains no information&quot;</span>,
<span class="number">0x01 </span>=&gt; <span class="string">&quot;Instruction TLB: 4 KByte pages, 4-way set associative, 32 entries&quot;</span>,
<span class="number">0x02 </span>=&gt; <span class="string">&quot;Instruction TLB: 4 MByte pages, fully associative, 2 entries&quot;</span>,
<span class="number">0x03 </span>=&gt; <span class="string">&quot;Data TLB: 4 KByte pages, 4-way set associative, 64 entries&quot;</span>,
<span class="number">0x04 </span>=&gt; <span class="string">&quot;Data TLB: 4 MByte pages, 4-way set associative, 8 entries&quot;</span>,
<span class="number">0x05 </span>=&gt; <span class="string">&quot;Data TLB1: 4 MByte pages, 4-way set associative, 32 entries&quot;</span>,
<span class="number">0x06 </span>=&gt; <span class="string">&quot;1st-level instruction cache: 8 KBytes, 4-way set associative, 32 byte line size&quot;</span>,
<span class="number">0x08 </span>=&gt; <span class="string">&quot;1st-level instruction cache: 16 KBytes, 4-way set associative, 32 byte line size&quot;</span>,
<span class="number">0x09 </span>=&gt; <span class="string">&quot;1st-level instruction cache: 32KBytes, 4-way set associative, 64 byte line size&quot;</span>,
<span class="number">0x0A </span>=&gt; <span class="string">&quot;1st-level data cache: 8 KBytes, 2-way set associative, 32 byte line size&quot;</span>,
<span class="number">0x0B </span>=&gt; <span class="string">&quot;Instruction TLB: 4 MByte pages, 4-way set associative, 4 entries&quot;</span>,
<span class="number">0x0C </span>=&gt; <span class="string">&quot;1st-level data cache: 16 KBytes, 4-way set associative, 32 byte line size&quot;</span>,
<span class="number">0x0D </span>=&gt; <span class="string">&quot;1st-level data cache: 16 KBytes, 4-way set associative, 64 byte line size&quot;</span>,
<span class="number">0x0E </span>=&gt; <span class="string">&quot;1st-level data cache: 24 KBytes, 6-way set associative, 64 byte line size&quot;</span>,
<span class="number">0x1D </span>=&gt; <span class="string">&quot;2nd-level cache: 128 KBytes, 2-way set associative, 64 byte line size&quot;</span>,
<span class="number">0x21 </span>=&gt; <span class="string">&quot;2nd-level cache: 256 KBytes, 8-way set associative, 64 byte line size&quot;</span>,
<span class="number">0x22 </span>=&gt; <span class="string">&quot;3rd-level cache: 512 KBytes, 4-way set associative, 64 byte line size, 2 lines per sector&quot;</span>,
<span class="number">0x23 </span>=&gt; <span class="string">&quot;3rd-level cache: 1 MBytes, 8-way set associative, 64 byte line size, 2 lines per sector&quot;</span>,
<span class="number">0x24 </span>=&gt; <span class="string">&quot;2nd-level cache: 1 MBytes, 16-way set associative, 64 byte line size&quot;</span>,
<span class="number">0x25 </span>=&gt; <span class="string">&quot;3rd-level cache: 2 MBytes, 8-way set associative, 64 byte line size, 2 lines per sector&quot;</span>,
<span class="number">0x29 </span>=&gt; <span class="string">&quot;3rd-level cache: 4 MBytes, 8-way set associative, 64 byte line size, 2 lines per sector&quot;</span>,
<span class="number">0x2C </span>=&gt; <span class="string">&quot;1st-level data cache: 32 KBytes, 8-way set associative, 64 byte line size&quot;</span>,
<span class="number">0x30 </span>=&gt; <span class="string">&quot;1st-level instruction cache: 32 KBytes, 8-way set associative, 64 byte line size&quot;</span>,
<span class="number">0x40 </span>=&gt; <span class="string">&quot;No 2nd-level cache or, if processor contains a valid 2nd-level cache, no 3rd-level cache&quot;</span>,
<span class="number">0x41 </span>=&gt; <span class="string">&quot;2nd-level cache: 128 KBytes, 4-way set associative, 32 byte line size&quot;</span>,
<span class="number">0x42 </span>=&gt; <span class="string">&quot;2nd-level cache: 256 KBytes, 4-way set associative, 32 byte line size&quot;</span>,
<span class="number">0x43 </span>=&gt; <span class="string">&quot;2nd-level cache: 512 KBytes, 4-way set associative, 32 byte line size&quot;</span>,
<span class="number">0x44 </span>=&gt; <span class="string">&quot;2nd-level cache: 1 MByte, 4-way set associative, 32 byte line size&quot;</span>,
<span class="number">0x45 </span>=&gt; <span class="string">&quot;2nd-level cache: 2 MByte, 4-way set associative, 32 byte line size&quot;</span>,
<span class="number">0x46 </span>=&gt; <span class="string">&quot;3rd-level cache: 4 MByte, 4-way set associative, 64 byte line size&quot;</span>,
<span class="number">0x47 </span>=&gt; <span class="string">&quot;3rd-level cache: 8 MByte, 8-way set associative, 64 byte line size&quot;</span>,
<span class="number">0x48 </span>=&gt; <span class="string">&quot;2nd-level cache: 3MByte, 12-way set associative, 64 byte line size&quot;</span>,
<span class="number">0x49 </span>=&gt; <span class="string">&quot;3rd-level cache: 4MB, 16-way set associative, 64-byte line size (Intel Xeon processor MP, Family 0FH, Model 06H); 2nd-level cache: 4 MByte, 16-way set ssociative, 64 byte line size&quot;</span>,
<span class="number">0x4A </span>=&gt; <span class="string">&quot;3rd-level cache: 6MByte, 12-way set associative, 64 byte line size&quot;</span>,
<span class="number">0x4B </span>=&gt; <span class="string">&quot;3rd-level cache: 8MByte, 16-way set associative, 64 byte line size&quot;</span>,
<span class="number">0x4C </span>=&gt; <span class="string">&quot;3rd-level cache: 12MByte, 12-way set associative, 64 byte line size&quot;</span>,
<span class="number">0x4D </span>=&gt; <span class="string">&quot;3rd-level cache: 16MByte, 16-way set associative, 64 byte line size&quot;</span>,
<span class="number">0x4E </span>=&gt; <span class="string">&quot;2nd-level cache: 6MByte, 24-way set associative, 64 byte line size&quot;</span>,
<span class="number">0x4F </span>=&gt; <span class="string">&quot;Instruction TLB: 4 KByte pages, 32 entries&quot;</span>,
<span class="number">0x50 </span>=&gt; <span class="string">&quot;Instruction TLB: 4 KByte and 2-MByte or 4-MByte pages, 64 entries&quot;</span>,
<span class="number">0x51 </span>=&gt; <span class="string">&quot;Instruction TLB: 4 KByte and 2-MByte or 4-MByte pages, 128 entries&quot;</span>,
<span class="number">0x52 </span>=&gt; <span class="string">&quot;Instruction TLB: 4 KByte and 2-MByte or 4-MByte pages, 256 entries&quot;</span>,
<span class="number">0x55 </span>=&gt; <span class="string">&quot;Instruction TLB: 2-MByte or 4-MByte pages, fully associative, 7 entries&quot;</span>,
<span class="number">0x56 </span>=&gt; <span class="string">&quot;Data TLB0: 4 MByte pages, 4-way set associative, 16 entries&quot;</span>,
<span class="number">0x57 </span>=&gt; <span class="string">&quot;Data TLB0: 4 KByte pages, 4-way associative, 16 entries&quot;</span>,
<span class="number">0x59 </span>=&gt; <span class="string">&quot;Data TLB0: 4 KByte pages, fully associative, 16 entries&quot;</span>,
<span class="number">0x5A </span>=&gt; <span class="string">&quot;Data TLB0: 2-MByte or 4 MByte pages, 4-way set associative, 32 entries&quot;</span>,
<span class="number">0x5B </span>=&gt; <span class="string">&quot;Data TLB: 4 KByte and 4 MByte pages, 64 entries&quot;</span>,
<span class="number">0x5C </span>=&gt; <span class="string">&quot;Data TLB: 4 KByte and 4 MByte pages,128 entries&quot;</span>,
<span class="number">0x5D </span>=&gt; <span class="string">&quot;Data TLB: 4 KByte and 4 MByte pages,256 entries&quot;</span>,
<span class="number">0x60 </span>=&gt; <span class="string">&quot;1st-level data cache: 16 KByte, 8-way set associative, 64 byte line size&quot;</span>,
<span class="number">0x61 </span>=&gt; <span class="string">&quot;Instruction TLB: 4 KByte pages, fully associative, 48 entries&quot;</span>,
<span class="number">0x63 </span>=&gt; <span class="string">&quot;Data TLB: 2 MByte or 4 MByte pages, 4-way set associative, 32 entries and a separate array with 1 GByte pages, 4-way set associative, 4 entries&quot;</span>,
<span class="number">0x64 </span>=&gt; <span class="string">&quot;Data TLB: 4 KByte pages, 4-way set associative, 512 entries&quot;</span>,
<span class="number">0x66 </span>=&gt; <span class="string">&quot;1st-level data cache: 8 KByte, 4-way set associative, 64 byte line size&quot;</span>,
<span class="number">0x67 </span>=&gt; <span class="string">&quot;1st-level data cache: 16 KByte, 4-way set associative, 64 byte line size&quot;</span>,
<span class="number">0x68 </span>=&gt; <span class="string">&quot;1st-level data cache: 32 KByte, 4-way set associative, 64 byte line size&quot;</span>,
<span class="number">0x6A </span>=&gt; <span class="string">&quot;uTLB: 4 KByte pages, 8-way set associative, 64 entries&quot;</span>,
<span class="number">0x6B </span>=&gt; <span class="string">&quot;DTLB: 4 KByte pages, 8-way set associative, 256 entries&quot;</span>,
<span class="number">0x6C </span>=&gt; <span class="string">&quot;DTLB: 2M/4M pages, 8-way set associative, 128 entries&quot;</span>,
<span class="number">0x6D </span>=&gt; <span class="string">&quot;DTLB: 1 GByte pages, fully associative, 16 entries&quot;</span>,
<span class="number">0x70 </span>=&gt; <span class="string">&quot;Trace cache: 12 K-μop, 8-way set associative&quot;</span>,
<span class="number">0x71 </span>=&gt; <span class="string">&quot;Trace cache: 16 K-μop, 8-way set associative&quot;</span>,
<span class="number">0x72 </span>=&gt; <span class="string">&quot;Trace cache: 32 K-μop, 8-way set associative&quot;</span>,
<span class="number">0x76 </span>=&gt; <span class="string">&quot;Instruction TLB: 2M/4M pages, fully associative, 8 entries&quot;</span>,
<span class="number">0x78 </span>=&gt; <span class="string">&quot;2nd-level cache: 1 MByte, 4-way set associative, 64byte line size&quot;</span>,
<span class="number">0x79 </span>=&gt; <span class="string">&quot;2nd-level cache: 128 KByte, 8-way set associative, 64 byte line size, 2 lines per sector&quot;</span>,
<span class="number">0x7A </span>=&gt; <span class="string">&quot;2nd-level cache: 256 KByte, 8-way set associative, 64 byte line size, 2 lines per sector&quot;</span>,
<span class="number">0x7B </span>=&gt; <span class="string">&quot;2nd-level cache: 512 KByte, 8-way set associative, 64 byte line size, 2 lines per sector&quot;</span>,
<span class="number">0x7C </span>=&gt; <span class="string">&quot;2nd-level cache: 1 MByte, 8-way set associative, 64 byte line size, 2 lines per sector&quot;</span>,
<span class="number">0x7D </span>=&gt; <span class="string">&quot;2nd-level cache: 2 MByte, 8-way set associative, 64byte line size&quot;</span>,
<span class="number">0x7F </span>=&gt; <span class="string">&quot;2nd-level cache: 512 KByte, 2-way set associative, 64-byte line size&quot;</span>,
<span class="number">0x80 </span>=&gt; <span class="string">&quot;2nd-level cache: 512 KByte, 8-way set associative, 64-byte line size&quot;</span>,
<span class="number">0x82 </span>=&gt; <span class="string">&quot;2nd-level cache: 256 KByte, 8-way set associative, 32 byte line size&quot;</span>,
<span class="number">0x83 </span>=&gt; <span class="string">&quot;2nd-level cache: 512 KByte, 8-way set associative, 32 byte line size&quot;</span>,
<span class="number">0x84 </span>=&gt; <span class="string">&quot;2nd-level cache: 1 MByte, 8-way set associative, 32 byte line size&quot;</span>,
<span class="number">0x85 </span>=&gt; <span class="string">&quot;2nd-level cache: 2 MByte, 8-way set associative, 32 byte line size&quot;</span>,
<span class="number">0x86 </span>=&gt; <span class="string">&quot;2nd-level cache: 512 KByte, 4-way set associative, 64 byte line size&quot;</span>,
<span class="number">0x87 </span>=&gt; <span class="string">&quot;2nd-level cache: 1 MByte, 8-way set associative, 64 byte line size&quot;</span>,
<span class="number">0xA0 </span>=&gt; <span class="string">&quot;DTLB: 4k pages, fully associative, 32 entries&quot;</span>,
<span class="number">0xB0 </span>=&gt; <span class="string">&quot;Instruction TLB: 4 KByte pages, 4-way set associative, 128 entries&quot;</span>,
<span class="number">0xB1 </span>=&gt; <span class="string">&quot;Instruction TLB: 2M pages, 4-way, 8 entries or 4M pages, 4-way, 4 entries&quot;</span>,
<span class="number">0xB2 </span>=&gt; <span class="string">&quot;Instruction TLB: 4KByte pages, 4-way set associative, 64 entries&quot;</span>,
<span class="number">0xB3 </span>=&gt; <span class="string">&quot;Data TLB: 4 KByte pages, 4-way set associative, 128 entries&quot;</span>,
<span class="number">0xB4 </span>=&gt; <span class="string">&quot;Data TLB1: 4 KByte pages, 4-way associative, 256 entries&quot;</span>,
<span class="number">0xB5 </span>=&gt; <span class="string">&quot;Instruction TLB: 4KByte pages, 8-way set associative, 64 entries&quot;</span>,
<span class="number">0xB6 </span>=&gt; <span class="string">&quot;Instruction TLB: 4KByte pages, 8-way set associative, 128 entries&quot;</span>,
<span class="number">0xBA </span>=&gt; <span class="string">&quot;Data TLB1: 4 KByte pages, 4-way associative, 64 entries&quot;</span>,
<span class="number">0xC0 </span>=&gt; <span class="string">&quot;Data TLB: 4 KByte and 4 MByte pages, 4-way associative, 8 entries&quot;</span>,
<span class="number">0xC1 </span>=&gt; <span class="string">&quot;Shared 2nd-Level TLB: 4 KByte/2MByte pages, 8-way associative, 1024 entries&quot;</span>,
<span class="number">0xC2 </span>=&gt; <span class="string">&quot;DTLB: 2 MByte/$MByte pages, 4-way associative, 16 entries&quot;</span>,
<span class="number">0xC3 </span>=&gt; <span class="string">&quot;Shared 2nd-Level TLB: 4 KByte /2 MByte pages, 6-way associative, 1536 entries. Also 1GBbyte pages, 4-way, 16 entries.&quot;</span>,
<span class="number">0xC4 </span>=&gt; <span class="string">&quot;DTLB: 2M/4M Byte pages, 4-way associative, 32 entries&quot;</span>,
<span class="number">0xCA </span>=&gt; <span class="string">&quot;Shared 2nd-Level TLB: 4 KByte pages, 4-way associative, 512 entries&quot;</span>,
<span class="number">0xD0 </span>=&gt; <span class="string">&quot;3rd-level cache: 512 KByte, 4-way set associative, 64 byte line size&quot;</span>,
<span class="number">0xD1 </span>=&gt; <span class="string">&quot;3rd-level cache: 1 MByte, 4-way set associative, 64 byte line size&quot;</span>,
<span class="number">0xD2 </span>=&gt; <span class="string">&quot;3rd-level cache: 2 MByte, 4-way set associative, 64 byte line size&quot;</span>,
<span class="number">0xD6 </span>=&gt; <span class="string">&quot;3rd-level cache: 1 MByte, 8-way set associative, 64 byte line size&quot;</span>,
<span class="number">0xD7 </span>=&gt; <span class="string">&quot;3rd-level cache: 2 MByte, 8-way set associative, 64 byte line size&quot;</span>,
<span class="number">0xD8 </span>=&gt; <span class="string">&quot;3rd-level cache: 4 MByte, 8-way set associative, 64 byte line size&quot;</span>,
<span class="number">0xDC </span>=&gt; <span class="string">&quot;3rd-level cache: 1.5 MByte, 12-way set associative, 64 byte line size&quot;</span>,
<span class="number">0xDD </span>=&gt; <span class="string">&quot;3rd-level cache: 3 MByte, 12-way set associative, 64 byte line size&quot;</span>,
<span class="number">0xDE </span>=&gt; <span class="string">&quot;3rd-level cache: 6 MByte, 12-way set associative, 64 byte line size&quot;</span>,
<span class="number">0xE2 </span>=&gt; <span class="string">&quot;3rd-level cache: 2 MByte, 16-way set associative, 64 byte line size&quot;</span>,
<span class="number">0xE3 </span>=&gt; <span class="string">&quot;3rd-level cache: 4 MByte, 16-way set associative, 64 byte line size&quot;</span>,
<span class="number">0xE4 </span>=&gt; <span class="string">&quot;3rd-level cache: 8 MByte, 16-way set associative, 64 byte line size&quot;</span>,
<span class="number">0xEA </span>=&gt; <span class="string">&quot;3rd-level cache: 12MByte, 24-way set associative, 64 byte line size&quot;</span>,
<span class="number">0xEB </span>=&gt; <span class="string">&quot;3rd-level cache: 18MByte, 24-way set associative, 64 byte line size&quot;</span>,
<span class="number">0xEC </span>=&gt; <span class="string">&quot;3rd-level cache: 24MByte, 24-way set associative, 64 byte line size&quot;</span>,
<span class="number">0xF0 </span>=&gt; <span class="string">&quot;64-Byte prefetching&quot;</span>,
<span class="number">0xF1 </span>=&gt; <span class="string">&quot;128-Byte prefetching&quot;</span>,
<span class="number">0xFE </span>=&gt; <span class="string">&quot;CPUID leaf 2 does not report TLB descriptor information; use CPUID leaf 18H to query TLB and other address translation parameters.&quot;</span>,
<span class="number">0xFF </span>=&gt; <span class="string">&quot;CPUID leaf 2 does not report cache descriptor information, use CPUID leaf 4 to query cache parameters&quot;</span>,
<span class="kw">_ </span>=&gt; <span class="string">&quot;Unknown cache type!&quot;
</span>}
}
}
<span class="kw">impl </span>Debug <span class="kw">for </span>CacheInfo {
<span class="kw">fn </span>fmt(<span class="kw-2">&amp;</span><span class="self">self</span>, f: <span class="kw-2">&amp;mut </span>Formatter&lt;<span class="lifetime">&#39;_</span>&gt;) -&gt; fmt::Result {
f.debug_struct(<span class="string">&quot;CacheInfo&quot;</span>)
.field(<span class="string">&quot;typ&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.typ)
.field(<span class="string">&quot;desc&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.desc())
.finish()
}
}
<span class="kw">impl </span>fmt::Display <span class="kw">for </span>CacheInfo {
<span class="kw">fn </span>fmt(<span class="kw-2">&amp;</span><span class="self">self</span>, f: <span class="kw-2">&amp;mut </span>fmt::Formatter) -&gt; fmt::Result {
<span class="kw">let </span>typ = <span class="kw">match </span><span class="self">self</span>.typ {
CacheInfoType::General =&gt; <span class="string">&quot;N/A&quot;</span>,
CacheInfoType::Cache =&gt; <span class="string">&quot;Cache&quot;</span>,
CacheInfoType::TLB =&gt; <span class="string">&quot;TLB&quot;</span>,
CacheInfoType::STLB =&gt; <span class="string">&quot;STLB&quot;</span>,
CacheInfoType::DTLB =&gt; <span class="string">&quot;DTLB&quot;</span>,
CacheInfoType::Prefetch =&gt; <span class="string">&quot;Prefetcher&quot;</span>,
};
<span class="macro">write!</span>(f, <span class="string">&quot;{:x}:\t {}: {}&quot;</span>, <span class="self">self</span>.num, typ, <span class="self">self</span>.desc())
}
}
<span class="doccomment">/// This table is taken from Intel manual (Section CPUID instruction).
</span><span class="kw">pub const </span>CACHE_INFO_TABLE: [CacheInfo; <span class="number">108</span>] = [
CacheInfo {
num: <span class="number">0x00</span>,
typ: CacheInfoType::General,
},
CacheInfo {
num: <span class="number">0x01</span>,
typ: CacheInfoType::TLB,
},
CacheInfo {
num: <span class="number">0x02</span>,
typ: CacheInfoType::TLB,
},
CacheInfo {
num: <span class="number">0x03</span>,
typ: CacheInfoType::TLB,
},
CacheInfo {
num: <span class="number">0x04</span>,
typ: CacheInfoType::TLB,
},
CacheInfo {
num: <span class="number">0x05</span>,
typ: CacheInfoType::TLB,
},
CacheInfo {
num: <span class="number">0x06</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0x08</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0x09</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0x0A</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0x0B</span>,
typ: CacheInfoType::TLB,
},
CacheInfo {
num: <span class="number">0x0C</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0x0D</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0x0E</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0x21</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0x22</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0x23</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0x24</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0x25</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0x29</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0x2C</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0x30</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0x40</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0x41</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0x42</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0x43</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0x44</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0x45</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0x46</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0x47</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0x48</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0x49</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0x4A</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0x4B</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0x4C</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0x4D</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0x4E</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0x4F</span>,
typ: CacheInfoType::TLB,
},
CacheInfo {
num: <span class="number">0x50</span>,
typ: CacheInfoType::TLB,
},
CacheInfo {
num: <span class="number">0x51</span>,
typ: CacheInfoType::TLB,
},
CacheInfo {
num: <span class="number">0x52</span>,
typ: CacheInfoType::TLB,
},
CacheInfo {
num: <span class="number">0x55</span>,
typ: CacheInfoType::TLB,
},
CacheInfo {
num: <span class="number">0x56</span>,
typ: CacheInfoType::TLB,
},
CacheInfo {
num: <span class="number">0x57</span>,
typ: CacheInfoType::TLB,
},
CacheInfo {
num: <span class="number">0x59</span>,
typ: CacheInfoType::TLB,
},
CacheInfo {
num: <span class="number">0x5A</span>,
typ: CacheInfoType::TLB,
},
CacheInfo {
num: <span class="number">0x5B</span>,
typ: CacheInfoType::TLB,
},
CacheInfo {
num: <span class="number">0x5C</span>,
typ: CacheInfoType::TLB,
},
CacheInfo {
num: <span class="number">0x5D</span>,
typ: CacheInfoType::TLB,
},
CacheInfo {
num: <span class="number">0x60</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0x61</span>,
typ: CacheInfoType::TLB,
},
CacheInfo {
num: <span class="number">0x63</span>,
typ: CacheInfoType::TLB,
},
CacheInfo {
num: <span class="number">0x66</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0x67</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0x68</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0x6A</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0x6B</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0x6C</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0x6D</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0x70</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0x71</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0x72</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0x76</span>,
typ: CacheInfoType::TLB,
},
CacheInfo {
num: <span class="number">0x78</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0x79</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0x7A</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0x7B</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0x7C</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0x7D</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0x7F</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0x80</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0x82</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0x83</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0x84</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0x85</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0x86</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0x87</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0xB0</span>,
typ: CacheInfoType::TLB,
},
CacheInfo {
num: <span class="number">0xB1</span>,
typ: CacheInfoType::TLB,
},
CacheInfo {
num: <span class="number">0xB2</span>,
typ: CacheInfoType::TLB,
},
CacheInfo {
num: <span class="number">0xB3</span>,
typ: CacheInfoType::TLB,
},
CacheInfo {
num: <span class="number">0xB4</span>,
typ: CacheInfoType::TLB,
},
CacheInfo {
num: <span class="number">0xB5</span>,
typ: CacheInfoType::TLB,
},
CacheInfo {
num: <span class="number">0xB6</span>,
typ: CacheInfoType::TLB,
},
CacheInfo {
num: <span class="number">0xBA</span>,
typ: CacheInfoType::TLB,
},
CacheInfo {
num: <span class="number">0xC0</span>,
typ: CacheInfoType::TLB,
},
CacheInfo {
num: <span class="number">0xC1</span>,
typ: CacheInfoType::STLB,
},
CacheInfo {
num: <span class="number">0xC2</span>,
typ: CacheInfoType::DTLB,
},
CacheInfo {
num: <span class="number">0xCA</span>,
typ: CacheInfoType::STLB,
},
CacheInfo {
num: <span class="number">0xD0</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0xD1</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0xD2</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0xD6</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0xD7</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0xD8</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0xDC</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0xDD</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0xDE</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0xE2</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0xE3</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0xE4</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0xEA</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0xEB</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0xEC</span>,
typ: CacheInfoType::Cache,
},
CacheInfo {
num: <span class="number">0xF0</span>,
typ: CacheInfoType::Prefetch,
},
CacheInfo {
num: <span class="number">0xF1</span>,
typ: CacheInfoType::Prefetch,
},
CacheInfo {
num: <span class="number">0xFE</span>,
typ: CacheInfoType::General,
},
CacheInfo {
num: <span class="number">0xFF</span>,
typ: CacheInfoType::General,
},
];
<span class="doccomment">/// Processor Serial Number (LEAF=0x3).
///
/// # Deprecated
///
/// Processor serial number (PSN) is not supported in the Pentium 4 processor or
/// later. On all models, use the PSN flag (returned using CPUID) to check for
/// PSN support before accessing the feature.
///
/// # Platforms
/// ❌ AMD ✅ Intel
</span><span class="attribute">#[derive(PartialEq, Eq)]
#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, derive(Serialize, Deserialize))]
</span><span class="kw">pub struct </span>ProcessorSerial {
<span class="doccomment">/// Lower bits
</span>ecx: u32,
<span class="doccomment">/// Middle bits
</span>edx: u32,
<span class="doccomment">/// Upper bits (come from leaf 0x1)
</span>eax: u32,
}
<span class="kw">impl </span>ProcessorSerial {
<span class="doccomment">/// Bits 00-31 of 96 bit processor serial number.
///
/// (Available in Pentium III processor only; otherwise, the value in this register is reserved.)
</span><span class="kw">pub fn </span>serial_lower(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u32 {
<span class="self">self</span>.ecx
}
<span class="doccomment">/// Bits 32-63 of 96 bit processor serial number.
///
/// (Available in Pentium III processor only; otherwise, the value in this register is reserved.)
</span><span class="kw">pub fn </span>serial_middle(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u32 {
<span class="self">self</span>.edx
}
<span class="doccomment">/// Bits 64-96 of 96 bit processor serial number.
</span><span class="kw">pub fn </span>serial_upper(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u32 {
<span class="self">self</span>.eax
}
<span class="doccomment">/// Combination of bits 00-31 and 32-63 of 96 bit processor serial number.
</span><span class="kw">pub fn </span>serial(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u64 {
(<span class="self">self</span>.serial_lower() <span class="kw">as </span>u64) | (<span class="self">self</span>.serial_middle() <span class="kw">as </span>u64) &lt;&lt; <span class="number">32
</span>}
<span class="doccomment">/// 96 bit processor serial number.
</span><span class="kw">pub fn </span>serial_all(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u128 {
(<span class="self">self</span>.serial_lower() <span class="kw">as </span>u128)
| ((<span class="self">self</span>.serial_middle() <span class="kw">as </span>u128) &lt;&lt; <span class="number">32</span>)
| ((<span class="self">self</span>.serial_upper() <span class="kw">as </span>u128) &lt;&lt; <span class="number">64</span>)
}
}
<span class="kw">impl </span>Debug <span class="kw">for </span>ProcessorSerial {
<span class="kw">fn </span>fmt(<span class="kw-2">&amp;</span><span class="self">self</span>, f: <span class="kw-2">&amp;mut </span>Formatter&lt;<span class="lifetime">&#39;_</span>&gt;) -&gt; core::fmt::Result {
f.debug_struct(<span class="string">&quot;ProcessorSerial&quot;</span>)
.field(<span class="string">&quot;serial_lower&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.serial_lower())
.field(<span class="string">&quot;serial_middle&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.serial_middle())
.finish()
}
}
<span class="doccomment">/// Processor and Processor Feature Identifiers (LEAF=0x01).
///
/// # Platforms
/// ✅ AMD ✅ Intel
</span><span class="attribute">#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, derive(Serialize, Deserialize))]
</span><span class="kw">pub struct </span>FeatureInfo {
vendor: Vendor,
eax: u32,
ebx: u32,
edx_ecx: FeatureInfoFlags,
}
<span class="kw">impl </span>FeatureInfo {
<span class="doccomment">/// Version Information: Extended Family
</span><span class="kw">pub fn </span>extended_family_id(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u8 {
get_bits(<span class="self">self</span>.eax, <span class="number">20</span>, <span class="number">27</span>) <span class="kw">as </span>u8
}
<span class="doccomment">/// Version Information: Extended Model
</span><span class="kw">pub fn </span>extended_model_id(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u8 {
get_bits(<span class="self">self</span>.eax, <span class="number">16</span>, <span class="number">19</span>) <span class="kw">as </span>u8
}
<span class="doccomment">/// Version Information: Family
</span><span class="kw">pub fn </span>base_family_id(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u8 {
get_bits(<span class="self">self</span>.eax, <span class="number">8</span>, <span class="number">11</span>) <span class="kw">as </span>u8
}
<span class="doccomment">/// Version Information: Model
</span><span class="kw">pub fn </span>base_model_id(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u8 {
get_bits(<span class="self">self</span>.eax, <span class="number">4</span>, <span class="number">7</span>) <span class="kw">as </span>u8
}
<span class="kw">pub fn </span>family_id(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u8 {
<span class="kw">let </span>base_family_id = <span class="self">self</span>.base_family_id();
<span class="kw">let </span>extended_family_id = <span class="self">self</span>.extended_family_id();
<span class="kw">let </span>just_use_base = (<span class="self">self</span>.vendor == Vendor::Amd &amp;&amp; base_family_id &lt; <span class="number">0xf</span>)
|| (<span class="self">self</span>.vendor == Vendor::Intel &amp;&amp; base_family_id != <span class="number">0xf</span>);
<span class="kw">if </span>just_use_base {
base_family_id
} <span class="kw">else </span>{
base_family_id + extended_family_id
}
}
<span class="kw">pub fn </span>model_id(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u8 {
<span class="kw">let </span>base_family_id = <span class="self">self</span>.base_family_id();
<span class="kw">let </span>base_model_id = <span class="self">self</span>.base_model_id();
<span class="kw">let </span>extended_model_id = <span class="self">self</span>.extended_model_id();
<span class="kw">let </span>just_use_base = (<span class="self">self</span>.vendor == Vendor::Amd &amp;&amp; base_family_id &lt; <span class="number">0xf</span>)
|| (<span class="self">self</span>.vendor == Vendor::Intel &amp;&amp; base_family_id != <span class="number">0xf </span>&amp;&amp; base_family_id != <span class="number">0x6</span>);
<span class="kw">if </span>just_use_base {
base_model_id
} <span class="kw">else </span>{
(extended_model_id &lt;&lt; <span class="number">4</span>) | base_model_id
}
}
<span class="doccomment">/// Version Information: Stepping ID
</span><span class="kw">pub fn </span>stepping_id(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u8 {
get_bits(<span class="self">self</span>.eax, <span class="number">0</span>, <span class="number">3</span>) <span class="kw">as </span>u8
}
<span class="doccomment">/// Brand Index
</span><span class="kw">pub fn </span>brand_index(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u8 {
get_bits(<span class="self">self</span>.ebx, <span class="number">0</span>, <span class="number">7</span>) <span class="kw">as </span>u8
}
<span class="doccomment">/// CLFLUSH line size (Value ∗ 8 = cache line size in bytes)
</span><span class="kw">pub fn </span>cflush_cache_line_size(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u8 {
get_bits(<span class="self">self</span>.ebx, <span class="number">8</span>, <span class="number">15</span>) <span class="kw">as </span>u8
}
<span class="doccomment">/// Initial APIC ID
</span><span class="kw">pub fn </span>initial_local_apic_id(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u8 {
get_bits(<span class="self">self</span>.ebx, <span class="number">24</span>, <span class="number">31</span>) <span class="kw">as </span>u8
}
<span class="doccomment">/// Maximum number of addressable IDs for logical processors in this physical package.
</span><span class="kw">pub fn </span>max_logical_processor_ids(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u8 {
get_bits(<span class="self">self</span>.ebx, <span class="number">16</span>, <span class="number">23</span>) <span class="kw">as </span>u8
}
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;Streaming SIMD Extensions 3 (SSE3). A value of 1 indicates the processor \
supports this technology.&quot;</span>,
has_sse3,
edx_ecx,
FeatureInfoFlags::SSE3
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;PCLMULQDQ. A value of 1 indicates the processor supports the PCLMULQDQ \
instruction&quot;</span>,
has_pclmulqdq,
edx_ecx,
FeatureInfoFlags::PCLMULQDQ
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;64-bit DS Area. A value of 1 indicates the processor supports DS area \
using 64-bit layout&quot;</span>,
has_ds_area,
edx_ecx,
FeatureInfoFlags::DTES64
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;MONITOR/MWAIT. A value of 1 indicates the processor supports this feature.&quot;</span>,
has_monitor_mwait,
edx_ecx,
FeatureInfoFlags::MONITOR
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;CPL Qualified Debug Store. A value of 1 indicates the processor supports \
the extensions to the Debug Store feature to allow for branch message \
storage qualified by CPL.&quot;</span>,
has_cpl,
edx_ecx,
FeatureInfoFlags::DSCPL
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;Virtual Machine Extensions. A value of 1 indicates that the processor \
supports this technology.&quot;</span>,
has_vmx,
edx_ecx,
FeatureInfoFlags::VMX
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;Safer Mode Extensions. A value of 1 indicates that the processor supports \
this technology. See Chapter 5, Safer Mode Extensions Reference.&quot;</span>,
has_smx,
edx_ecx,
FeatureInfoFlags::SMX
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;Enhanced Intel SpeedStep® technology. A value of 1 indicates that the \
processor supports this technology.&quot;</span>,
has_eist,
edx_ecx,
FeatureInfoFlags::EIST
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;Thermal Monitor 2. A value of 1 indicates whether the processor supports \
this technology.&quot;</span>,
has_tm2,
edx_ecx,
FeatureInfoFlags::TM2
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;A value of 1 indicates the presence of the Supplemental Streaming SIMD \
Extensions 3 (SSSE3). A value of 0 indicates the instruction extensions \
are not present in the processor&quot;</span>,
has_ssse3,
edx_ecx,
FeatureInfoFlags::SSSE3
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;L1 Context ID. A value of 1 indicates the L1 data cache mode can be set \
to either adaptive mode or shared mode. A value of 0 indicates this \
feature is not supported. See definition of the IA32_MISC_ENABLE MSR Bit \
24 (L1 Data Cache Context Mode) for details.&quot;</span>,
has_cnxtid,
edx_ecx,
FeatureInfoFlags::CNXTID
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;A value of 1 indicates the processor supports FMA extensions using YMM \
state.&quot;</span>,
has_fma,
edx_ecx,
FeatureInfoFlags::FMA
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;CMPXCHG16B Available. A value of 1 indicates that the feature is \
available. See the CMPXCHG8B/CMPXCHG16B Compare and Exchange Bytes \
section. 14&quot;</span>,
has_cmpxchg16b,
edx_ecx,
FeatureInfoFlags::CMPXCHG16B
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;Perfmon and Debug Capability: A value of 1 indicates the processor \
supports the performance and debug feature indication MSR \
IA32_PERF_CAPABILITIES.&quot;</span>,
has_pdcm,
edx_ecx,
FeatureInfoFlags::PDCM
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;Process-context identifiers. A value of 1 indicates that the processor \
supports PCIDs and the software may set CR4.PCIDE to 1.&quot;</span>,
has_pcid,
edx_ecx,
FeatureInfoFlags::PCID
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;A value of 1 indicates the processor supports the ability to prefetch \
data from a memory mapped device.&quot;</span>,
has_dca,
edx_ecx,
FeatureInfoFlags::DCA
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;A value of 1 indicates that the processor supports SSE4.1.&quot;</span>,
has_sse41,
edx_ecx,
FeatureInfoFlags::SSE41
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;A value of 1 indicates that the processor supports SSE4.2.&quot;</span>,
has_sse42,
edx_ecx,
FeatureInfoFlags::SSE42
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;A value of 1 indicates that the processor supports x2APIC feature.&quot;</span>,
has_x2apic,
edx_ecx,
FeatureInfoFlags::X2APIC
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;A value of 1 indicates that the processor supports MOVBE instruction.&quot;</span>,
has_movbe,
edx_ecx,
FeatureInfoFlags::MOVBE
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;A value of 1 indicates that the processor supports the POPCNT instruction.&quot;</span>,
has_popcnt,
edx_ecx,
FeatureInfoFlags::POPCNT
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;A value of 1 indicates that the processors local APIC timer supports \
one-shot operation using a TSC deadline value.&quot;</span>,
has_tsc_deadline,
edx_ecx,
FeatureInfoFlags::TSC_DEADLINE
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;A value of 1 indicates that the processor supports the AESNI instruction \
extensions.&quot;</span>,
has_aesni,
edx_ecx,
FeatureInfoFlags::AESNI
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;A value of 1 indicates that the processor supports the XSAVE/XRSTOR \
processor extended states feature, the XSETBV/XGETBV instructions, and \
XCR0.&quot;</span>,
has_xsave,
edx_ecx,
FeatureInfoFlags::XSAVE
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;A value of 1 indicates that the OS has enabled XSETBV/XGETBV instructions \
to access XCR0, and support for processor extended state management using \
XSAVE/XRSTOR.&quot;</span>,
has_oxsave,
edx_ecx,
FeatureInfoFlags::OSXSAVE
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;A value of 1 indicates the processor supports the AVX instruction \
extensions.&quot;</span>,
has_avx,
edx_ecx,
FeatureInfoFlags::AVX
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;A value of 1 indicates that processor supports 16-bit floating-point \
conversion instructions.&quot;</span>,
has_f16c,
edx_ecx,
FeatureInfoFlags::F16C
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;A value of 1 indicates that processor supports RDRAND instruction.&quot;</span>,
has_rdrand,
edx_ecx,
FeatureInfoFlags::RDRAND
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;A value of 1 indicates the indicates the presence of a hypervisor.&quot;</span>,
has_hypervisor,
edx_ecx,
FeatureInfoFlags::HYPERVISOR
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;Floating Point Unit On-Chip. The processor contains an x87 FPU.&quot;</span>,
has_fpu,
edx_ecx,
FeatureInfoFlags::FPU
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;Virtual 8086 Mode Enhancements. Virtual 8086 mode enhancements, including \
CR4.VME for controlling the feature, CR4.PVI for protected mode virtual \
interrupts, software interrupt indirection, expansion of the TSS with the \
software indirection bitmap, and EFLAGS.VIF and EFLAGS.VIP flags.&quot;</span>,
has_vme,
edx_ecx,
FeatureInfoFlags::VME
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;Debugging Extensions. Support for I/O breakpoints, including CR4.DE for \
controlling the feature, and optional trapping of accesses to DR4 and DR5.&quot;</span>,
has_de,
edx_ecx,
FeatureInfoFlags::DE
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;Page Size Extension. Large pages of size 4 MByte are supported, including \
CR4.PSE for controlling the feature, the defined dirty bit in PDE (Page \
Directory Entries), optional reserved bit trapping in CR3, PDEs, and PTEs.&quot;</span>,
has_pse,
edx_ecx,
FeatureInfoFlags::PSE
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;Time Stamp Counter. The RDTSC instruction is supported, including CR4.TSD \
for controlling privilege.&quot;</span>,
has_tsc,
edx_ecx,
FeatureInfoFlags::TSC
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;Model Specific Registers RDMSR and WRMSR Instructions. The RDMSR and \
WRMSR instructions are supported. Some of the MSRs are implementation \
dependent.&quot;</span>,
has_msr,
edx_ecx,
FeatureInfoFlags::MSR
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;Physical Address Extension. Physical addresses greater than 32 bits are \
supported: extended page table entry formats, an extra level in the page \
translation tables is defined, 2-MByte pages are supported instead of 4 \
Mbyte pages if PAE bit is 1.&quot;</span>,
has_pae,
edx_ecx,
FeatureInfoFlags::PAE
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;Machine Check Exception. Exception 18 is defined for Machine Checks, \
including CR4.MCE for controlling the feature. This feature does not \
define the model-specific implementations of machine-check error logging, \
reporting, and processor shutdowns. Machine Check exception handlers may \
have to depend on processor version to do model specific processing of \
the exception, or test for the presence of the Machine Check feature.&quot;</span>,
has_mce,
edx_ecx,
FeatureInfoFlags::MCE
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;CMPXCHG8B Instruction. The compare-and-exchange 8 bytes (64 bits) \
instruction is supported (implicitly locked and atomic).&quot;</span>,
has_cmpxchg8b,
edx_ecx,
FeatureInfoFlags::CX8
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;APIC On-Chip. The processor contains an Advanced Programmable Interrupt \
Controller (APIC), responding to memory mapped commands in the physical \
address range FFFE0000H to FFFE0FFFH (by default - some processors permit \
the APIC to be relocated).&quot;</span>,
has_apic,
edx_ecx,
FeatureInfoFlags::APIC
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;SYSENTER and SYSEXIT Instructions. The SYSENTER and SYSEXIT and \
associated MSRs are supported.&quot;</span>,
has_sysenter_sysexit,
edx_ecx,
FeatureInfoFlags::SEP
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;Memory Type Range Registers. MTRRs are supported. The MTRRcap MSR \
contains feature bits that describe what memory types are supported, how \
many variable MTRRs are supported, and whether fixed MTRRs are supported.&quot;</span>,
has_mtrr,
edx_ecx,
FeatureInfoFlags::MTRR
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;Page Global Bit. The global bit is supported in paging-structure entries \
that map a page, indicating TLB entries that are common to different \
processes and need not be flushed. The CR4.PGE bit controls this feature.&quot;</span>,
has_pge,
edx_ecx,
FeatureInfoFlags::PGE
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;Machine Check Architecture. A value of 1 indicates the Machine Check \
Architecture of reporting machine errors is supported. The MCG_CAP MSR \
contains feature bits describing how many banks of error reporting MSRs \
are supported.&quot;</span>,
has_mca,
edx_ecx,
FeatureInfoFlags::MCA
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;Conditional Move Instructions. The conditional move instruction CMOV is \
supported. In addition, if x87 FPU is present as indicated by the \
CPUID.FPU feature bit, then the FCOMI and FCMOV instructions are supported&quot;</span>,
has_cmov,
edx_ecx,
FeatureInfoFlags::CMOV
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;Page Attribute Table. Page Attribute Table is supported. This feature \
augments the Memory Type Range Registers (MTRRs), allowing an operating \
system to specify attributes of memory accessed through a linear address \
on a 4KB granularity.&quot;</span>,
has_pat,
edx_ecx,
FeatureInfoFlags::PAT
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;36-Bit Page Size Extension. 4-MByte pages addressing physical memory \
beyond 4 GBytes are supported with 32-bit paging. This feature indicates \
that upper bits of the physical address of a 4-MByte page are encoded in \
bits 20:13 of the page-directory entry. Such physical addresses are \
limited by MAXPHYADDR and may be up to 40 bits in size.&quot;</span>,
has_pse36,
edx_ecx,
FeatureInfoFlags::PSE36
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;Processor Serial Number. The processor supports the 96-bit processor \
identification number feature and the feature is enabled.&quot;</span>,
has_psn,
edx_ecx,
FeatureInfoFlags::PSN
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;CLFLUSH Instruction. CLFLUSH Instruction is supported.&quot;</span>,
has_clflush,
edx_ecx,
FeatureInfoFlags::CLFSH
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;Debug Store. The processor supports the ability to write debug \
information into a memory resident buffer. This feature is used by the \
branch trace store (BTS) and processor event-based sampling (PEBS) \
facilities (see Chapter 23, Introduction to Virtual-Machine Extensions, \
in the Intel® 64 and IA-32 Architectures Software Developers Manual, \
Volume 3C).&quot;</span>,
has_ds,
edx_ecx,
FeatureInfoFlags::DS
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;Thermal Monitor and Software Controlled Clock Facilities. The processor \
implements internal MSRs that allow processor temperature to be monitored \
and processor performance to be modulated in predefined duty cycles under \
software control.&quot;</span>,
has_acpi,
edx_ecx,
FeatureInfoFlags::ACPI
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;Intel MMX Technology. The processor supports the Intel MMX technology.&quot;</span>,
has_mmx,
edx_ecx,
FeatureInfoFlags::MMX
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;FXSAVE and FXRSTOR Instructions. The FXSAVE and FXRSTOR instructions are \
supported for fast save and restore of the floating point context. \
Presence of this bit also indicates that CR4.OSFXSR is available for an \
operating system to indicate that it supports the FXSAVE and FXRSTOR \
instructions.&quot;</span>,
has_fxsave_fxstor,
edx_ecx,
FeatureInfoFlags::FXSR
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;SSE. The processor supports the SSE extensions.&quot;</span>,
has_sse,
edx_ecx,
FeatureInfoFlags::SSE
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;SSE2. The processor supports the SSE2 extensions.&quot;</span>,
has_sse2,
edx_ecx,
FeatureInfoFlags::SSE2
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;Self Snoop. The processor supports the management of conflicting memory \
types by performing a snoop of its own cache structure for transactions \
issued to the bus.&quot;</span>,
has_ss,
edx_ecx,
FeatureInfoFlags::SS
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;Max APIC IDs reserved field is Valid. A value of 0 for HTT indicates \
there is only a single logical processor in the package and software \
should assume only a single APIC ID is reserved. A value of 1 for HTT \
indicates the value in CPUID.1.EBX\\[23:16\\] (the Maximum number of \
addressable IDs for logical processors in this package) is valid for the \
package.&quot;</span>,
has_htt,
edx_ecx,
FeatureInfoFlags::HTT
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;Thermal Monitor. The processor implements the thermal monitor automatic \
thermal control circuitry (TCC).&quot;</span>,
has_tm,
edx_ecx,
FeatureInfoFlags::TM
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;Pending Break Enable. The processor supports the use of the FERR#/PBE# \
pin when the processor is in the stop-clock state (STPCLK# is asserted) \
to signal the processor that an interrupt is pending and that the \
processor should return to normal operation to handle the interrupt. Bit \
10 (PBE enable) in the IA32_MISC_ENABLE MSR enables this capability.&quot;</span>,
has_pbe,
edx_ecx,
FeatureInfoFlags::PBE
);
}
<span class="kw">impl </span>Debug <span class="kw">for </span>FeatureInfo {
<span class="kw">fn </span>fmt(<span class="kw-2">&amp;</span><span class="self">self</span>, f: <span class="kw-2">&amp;mut </span>Formatter&lt;<span class="lifetime">&#39;_</span>&gt;) -&gt; core::fmt::Result {
f.debug_struct(<span class="string">&quot;FeatureInfo&quot;</span>)
.field(<span class="string">&quot;extended_family_id&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.extended_family_id())
.field(<span class="string">&quot;extended_model_id&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.extended_model_id())
.field(<span class="string">&quot;family_id&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.family_id())
.field(<span class="string">&quot;model_id&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.model_id())
.field(<span class="string">&quot;stepping_id&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.stepping_id())
.field(<span class="string">&quot;brand_index&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.brand_index())
.field(<span class="string">&quot;cflush_cache_line_size&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.cflush_cache_line_size())
.field(<span class="string">&quot;initial_local_apic_id&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.initial_local_apic_id())
.field(
<span class="string">&quot;max_logical_processor_ids&quot;</span>,
<span class="kw-2">&amp;</span><span class="self">self</span>.max_logical_processor_ids(),
)
.field(<span class="string">&quot;edx_ecx&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.edx_ecx)
.finish()
}
}
<span class="macro">bitflags! </span>{
<span class="attribute">#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, derive(Serialize, Deserialize))]
</span><span class="kw">struct </span>FeatureInfoFlags: u64 {
<span class="comment">// ECX flags
</span><span class="doccomment">/// Streaming SIMD Extensions 3 (SSE3). A value of 1 indicates the processor supports this technology.
</span><span class="kw">const </span>SSE3 = <span class="number">1 </span>&lt;&lt; <span class="number">0</span>;
<span class="doccomment">/// PCLMULQDQ. A value of 1 indicates the processor supports the PCLMULQDQ instruction
</span><span class="kw">const </span>PCLMULQDQ = <span class="number">1 </span>&lt;&lt; <span class="number">1</span>;
<span class="doccomment">/// 64-bit DS Area. A value of 1 indicates the processor supports DS area using 64-bit layout
</span><span class="kw">const </span>DTES64 = <span class="number">1 </span>&lt;&lt; <span class="number">2</span>;
<span class="doccomment">/// MONITOR/MWAIT. A value of 1 indicates the processor supports this feature.
</span><span class="kw">const </span>MONITOR = <span class="number">1 </span>&lt;&lt; <span class="number">3</span>;
<span class="doccomment">/// CPL Qualified Debug Store. A value of 1 indicates the processor supports the extensions to the Debug Store feature to allow for branch message storage qualified by CPL.
</span><span class="kw">const </span>DSCPL = <span class="number">1 </span>&lt;&lt; <span class="number">4</span>;
<span class="doccomment">/// Virtual Machine Extensions. A value of 1 indicates that the processor supports this technology.
</span><span class="kw">const </span>VMX = <span class="number">1 </span>&lt;&lt; <span class="number">5</span>;
<span class="doccomment">/// Safer Mode Extensions. A value of 1 indicates that the processor supports this technology. See Chapter 5, Safer Mode Extensions Reference.
</span><span class="kw">const </span>SMX = <span class="number">1 </span>&lt;&lt; <span class="number">6</span>;
<span class="doccomment">/// Enhanced Intel SpeedStep® technology. A value of 1 indicates that the processor supports this technology.
</span><span class="kw">const </span>EIST = <span class="number">1 </span>&lt;&lt; <span class="number">7</span>;
<span class="doccomment">/// Thermal Monitor 2. A value of 1 indicates whether the processor supports this technology.
</span><span class="kw">const </span>TM2 = <span class="number">1 </span>&lt;&lt; <span class="number">8</span>;
<span class="doccomment">/// A value of 1 indicates the presence of the Supplemental Streaming SIMD Extensions 3 (SSSE3). A value of 0 indicates the instruction extensions are not present in the processor
</span><span class="kw">const </span>SSSE3 = <span class="number">1 </span>&lt;&lt; <span class="number">9</span>;
<span class="doccomment">/// L1 Context ID. A value of 1 indicates the L1 data cache mode can be set to either adaptive mode or shared mode. A value of 0 indicates this feature is not supported. See definition of the IA32_MISC_ENABLE MSR Bit 24 (L1 Data Cache Context Mode) for details.
</span><span class="kw">const </span>CNXTID = <span class="number">1 </span>&lt;&lt; <span class="number">10</span>;
<span class="doccomment">/// A value of 1 indicates the processor supports FMA extensions using YMM state.
</span><span class="kw">const </span>FMA = <span class="number">1 </span>&lt;&lt; <span class="number">12</span>;
<span class="doccomment">/// CMPXCHG16B Available. A value of 1 indicates that the feature is available. See the CMPXCHG8B/CMPXCHG16B Compare and Exchange Bytes section. 14
</span><span class="kw">const </span>CMPXCHG16B = <span class="number">1 </span>&lt;&lt; <span class="number">13</span>;
<span class="doccomment">/// Perfmon and Debug Capability: A value of 1 indicates the processor supports the performance and debug feature indication MSR IA32_PERF_CAPABILITIES.
</span><span class="kw">const </span>PDCM = <span class="number">1 </span>&lt;&lt; <span class="number">15</span>;
<span class="doccomment">/// Process-context identifiers. A value of 1 indicates that the processor supports PCIDs and the software may set CR4.PCIDE to 1.
</span><span class="kw">const </span>PCID = <span class="number">1 </span>&lt;&lt; <span class="number">17</span>;
<span class="doccomment">/// A value of 1 indicates the processor supports the ability to prefetch data from a memory mapped device.
</span><span class="kw">const </span>DCA = <span class="number">1 </span>&lt;&lt; <span class="number">18</span>;
<span class="doccomment">/// A value of 1 indicates that the processor supports SSE4.1.
</span><span class="kw">const </span>SSE41 = <span class="number">1 </span>&lt;&lt; <span class="number">19</span>;
<span class="doccomment">/// A value of 1 indicates that the processor supports SSE4.2.
</span><span class="kw">const </span>SSE42 = <span class="number">1 </span>&lt;&lt; <span class="number">20</span>;
<span class="doccomment">/// A value of 1 indicates that the processor supports x2APIC feature.
</span><span class="kw">const </span>X2APIC = <span class="number">1 </span>&lt;&lt; <span class="number">21</span>;
<span class="doccomment">/// A value of 1 indicates that the processor supports MOVBE instruction.
</span><span class="kw">const </span>MOVBE = <span class="number">1 </span>&lt;&lt; <span class="number">22</span>;
<span class="doccomment">/// A value of 1 indicates that the processor supports the POPCNT instruction.
</span><span class="kw">const </span>POPCNT = <span class="number">1 </span>&lt;&lt; <span class="number">23</span>;
<span class="doccomment">/// A value of 1 indicates that the processors local APIC timer supports one-shot operation using a TSC deadline value.
</span><span class="kw">const </span>TSC_DEADLINE = <span class="number">1 </span>&lt;&lt; <span class="number">24</span>;
<span class="doccomment">/// A value of 1 indicates that the processor supports the AESNI instruction extensions.
</span><span class="kw">const </span>AESNI = <span class="number">1 </span>&lt;&lt; <span class="number">25</span>;
<span class="doccomment">/// A value of 1 indicates that the processor supports the XSAVE/XRSTOR processor extended states feature, the XSETBV/XGETBV instructions, and XCR0.
</span><span class="kw">const </span>XSAVE = <span class="number">1 </span>&lt;&lt; <span class="number">26</span>;
<span class="doccomment">/// A value of 1 indicates that the OS has enabled XSETBV/XGETBV instructions to access XCR0, and support for processor extended state management using XSAVE/XRSTOR.
</span><span class="kw">const </span>OSXSAVE = <span class="number">1 </span>&lt;&lt; <span class="number">27</span>;
<span class="doccomment">/// A value of 1 indicates the processor supports the AVX instruction extensions.
</span><span class="kw">const </span>AVX = <span class="number">1 </span>&lt;&lt; <span class="number">28</span>;
<span class="doccomment">/// A value of 1 indicates that processor supports 16-bit floating-point conversion instructions.
</span><span class="kw">const </span>F16C = <span class="number">1 </span>&lt;&lt; <span class="number">29</span>;
<span class="doccomment">/// A value of 1 indicates that processor supports RDRAND instruction.
</span><span class="kw">const </span>RDRAND = <span class="number">1 </span>&lt;&lt; <span class="number">30</span>;
<span class="doccomment">/// A value of 1 indicates the indicates the presence of a hypervisor.
</span><span class="kw">const </span>HYPERVISOR = <span class="number">1 </span>&lt;&lt; <span class="number">31</span>;
<span class="comment">// EDX flags
</span><span class="doccomment">/// Floating Point Unit On-Chip. The processor contains an x87 FPU.
</span><span class="kw">const </span>FPU = <span class="number">1 </span>&lt;&lt; <span class="number">32</span>;
<span class="doccomment">/// Virtual 8086 Mode Enhancements. Virtual 8086 mode enhancements, including CR4.VME for controlling the feature, CR4.PVI for protected mode virtual interrupts, software interrupt indirection, expansion of the TSS with the software indirection bitmap, and EFLAGS.VIF and EFLAGS.VIP flags.
</span><span class="kw">const </span>VME = <span class="number">1 </span>&lt;&lt; (<span class="number">32 </span>+ <span class="number">1</span>);
<span class="doccomment">/// Debugging Extensions. Support for I/O breakpoints, including CR4.DE for controlling the feature, and optional trapping of accesses to DR4 and DR5.
</span><span class="kw">const </span>DE = <span class="number">1 </span>&lt;&lt; (<span class="number">32 </span>+ <span class="number">2</span>);
<span class="doccomment">/// Page Size Extension. Large pages of size 4 MByte are supported, including CR4.PSE for controlling the feature, the defined dirty bit in PDE (Page Directory Entries), optional reserved bit trapping in CR3, PDEs, and PTEs.
</span><span class="kw">const </span>PSE = <span class="number">1 </span>&lt;&lt; (<span class="number">32 </span>+ <span class="number">3</span>);
<span class="doccomment">/// Time Stamp Counter. The RDTSC instruction is supported, including CR4.TSD for controlling privilege.
</span><span class="kw">const </span>TSC = <span class="number">1 </span>&lt;&lt; (<span class="number">32 </span>+ <span class="number">4</span>);
<span class="doccomment">/// Model Specific Registers RDMSR and WRMSR Instructions. The RDMSR and WRMSR instructions are supported. Some of the MSRs are implementation dependent.
</span><span class="kw">const </span>MSR = <span class="number">1 </span>&lt;&lt; (<span class="number">32 </span>+ <span class="number">5</span>);
<span class="doccomment">/// Physical Address Extension. Physical addresses greater than 32 bits are supported: extended page table entry formats, an extra level in the page translation tables is defined, 2-MByte pages are supported instead of 4 Mbyte pages if PAE bit is 1.
</span><span class="kw">const </span>PAE = <span class="number">1 </span>&lt;&lt; (<span class="number">32 </span>+ <span class="number">6</span>);
<span class="doccomment">/// Machine Check Exception. Exception 18 is defined for Machine Checks, including CR4.MCE for controlling the feature. This feature does not define the model-specific implementations of machine-check error logging, reporting, and processor shutdowns. Machine Check exception handlers may have to depend on processor version to do model specific processing of the exception, or test for the presence of the Machine Check feature.
</span><span class="kw">const </span>MCE = <span class="number">1 </span>&lt;&lt; (<span class="number">32 </span>+ <span class="number">7</span>);
<span class="doccomment">/// CMPXCHG8B Instruction. The compare-and-exchange 8 bytes (64 bits) instruction is supported (implicitly locked and atomic).
</span><span class="kw">const </span>CX8 = <span class="number">1 </span>&lt;&lt; (<span class="number">32 </span>+ <span class="number">8</span>);
<span class="doccomment">/// APIC On-Chip. The processor contains an Advanced Programmable Interrupt Controller (APIC), responding to memory mapped commands in the physical address range FFFE0000H to FFFE0FFFH (by default - some processors permit the APIC to be relocated).
</span><span class="kw">const </span>APIC = <span class="number">1 </span>&lt;&lt; (<span class="number">32 </span>+ <span class="number">9</span>);
<span class="doccomment">/// SYSENTER and SYSEXIT Instructions. The SYSENTER and SYSEXIT and associated MSRs are supported.
</span><span class="kw">const </span>SEP = <span class="number">1 </span>&lt;&lt; (<span class="number">32 </span>+ <span class="number">11</span>);
<span class="doccomment">/// Memory Type Range Registers. MTRRs are supported. The MTRRcap MSR contains feature bits that describe what memory types are supported, how many variable MTRRs are supported, and whether fixed MTRRs are supported.
</span><span class="kw">const </span>MTRR = <span class="number">1 </span>&lt;&lt; (<span class="number">32 </span>+ <span class="number">12</span>);
<span class="doccomment">/// Page Global Bit. The global bit is supported in paging-structure entries that map a page, indicating TLB entries that are common to different processes and need not be flushed. The CR4.PGE bit controls this feature.
</span><span class="kw">const </span>PGE = <span class="number">1 </span>&lt;&lt; (<span class="number">32 </span>+ <span class="number">13</span>);
<span class="doccomment">/// Machine Check Architecture. The Machine Check exArchitecture, which provides a compatible mechanism for error reporting in P6 family, Pentium 4, Intel Xeon processors, and future processors, is supported. The MCG_CAP MSR contains feature bits describing how many banks of error reporting MSRs are supported.
</span><span class="kw">const </span>MCA = <span class="number">1 </span>&lt;&lt; (<span class="number">32 </span>+ <span class="number">14</span>);
<span class="doccomment">/// Conditional Move Instructions. The conditional move instruction CMOV is supported. In addition, if x87 FPU is present as indicated by the CPUID.FPU feature bit, then the FCOMI and FCMOV instructions are supported
</span><span class="kw">const </span>CMOV = <span class="number">1 </span>&lt;&lt; (<span class="number">32 </span>+ <span class="number">15</span>);
<span class="doccomment">/// Page Attribute Table. Page Attribute Table is supported. This feature augments the Memory Type Range Registers (MTRRs), allowing an operating system to specify attributes of memory accessed through a linear address on a 4KB granularity.
</span><span class="kw">const </span>PAT = <span class="number">1 </span>&lt;&lt; (<span class="number">32 </span>+ <span class="number">16</span>);
<span class="doccomment">/// 36-Bit Page Size Extension. 4-MByte pages addressing physical memory beyond 4 GBytes are supported with 32-bit paging. This feature indicates that upper bits of the physical address of a 4-MByte page are encoded in bits 20:13 of the page-directory entry. Such physical addresses are limited by MAXPHYADDR and may be up to 40 bits in size.
</span><span class="kw">const </span>PSE36 = <span class="number">1 </span>&lt;&lt; (<span class="number">32 </span>+ <span class="number">17</span>);
<span class="doccomment">/// Processor Serial Number. The processor supports the 96-bit processor identification number feature and the feature is enabled.
</span><span class="kw">const </span>PSN = <span class="number">1 </span>&lt;&lt; (<span class="number">32 </span>+ <span class="number">18</span>);
<span class="doccomment">/// CLFLUSH Instruction. CLFLUSH Instruction is supported.
</span><span class="kw">const </span>CLFSH = <span class="number">1 </span>&lt;&lt; (<span class="number">32 </span>+ <span class="number">19</span>);
<span class="doccomment">/// Debug Store. The processor supports the ability to write debug information into a memory resident buffer. This feature is used by the branch trace store (BTS) and precise event-based sampling (PEBS) facilities (see Chapter 23, Introduction to Virtual-Machine Extensions, in the Intel® 64 and IA-32 Architectures Software Developers Manual, Volume 3C).
</span><span class="kw">const </span>DS = <span class="number">1 </span>&lt;&lt; (<span class="number">32 </span>+ <span class="number">21</span>);
<span class="doccomment">/// Thermal Monitor and Software Controlled Clock Facilities. The processor implements internal MSRs that allow processor temperature to be monitored and processor performance to be modulated in predefined duty cycles under software control.
</span><span class="kw">const </span>ACPI = <span class="number">1 </span>&lt;&lt; (<span class="number">32 </span>+ <span class="number">22</span>);
<span class="doccomment">/// Intel MMX Technology. The processor supports the Intel MMX technology.
</span><span class="kw">const </span>MMX = <span class="number">1 </span>&lt;&lt; (<span class="number">32 </span>+ <span class="number">23</span>);
<span class="doccomment">/// FXSAVE and FXRSTOR Instructions. The FXSAVE and FXRSTOR instructions are supported for fast save and restore of the floating point context. Presence of this bit also indicates that CR4.OSFXSR is available for an operating system to indicate that it supports the FXSAVE and FXRSTOR instructions.
</span><span class="kw">const </span>FXSR = <span class="number">1 </span>&lt;&lt; (<span class="number">32 </span>+ <span class="number">24</span>);
<span class="doccomment">/// SSE. The processor supports the SSE extensions.
</span><span class="kw">const </span>SSE = <span class="number">1 </span>&lt;&lt; (<span class="number">32 </span>+ <span class="number">25</span>);
<span class="doccomment">/// SSE2. The processor supports the SSE2 extensions.
</span><span class="kw">const </span>SSE2 = <span class="number">1 </span>&lt;&lt; (<span class="number">32 </span>+ <span class="number">26</span>);
<span class="doccomment">/// Self Snoop. The processor supports the management of conflicting memory types by performing a snoop of its own cache structure for transactions issued to the bus.
</span><span class="kw">const </span>SS = <span class="number">1 </span>&lt;&lt; (<span class="number">32 </span>+ <span class="number">27</span>);
<span class="doccomment">/// Max APIC IDs reserved field is Valid. A value of 0 for HTT indicates there is only a single logical processor in the package and software should assume only a single APIC ID is reserved. A value of 1 for HTT indicates the value in CPUID.1.EBX[23:16] (the Maximum number of addressable IDs for logical processors in this package) is valid for the package.
</span><span class="kw">const </span>HTT = <span class="number">1 </span>&lt;&lt; (<span class="number">32 </span>+ <span class="number">28</span>);
<span class="doccomment">/// Thermal Monitor. The processor implements the thermal monitor automatic thermal control circuitry (TCC).
</span><span class="kw">const </span>TM = <span class="number">1 </span>&lt;&lt; (<span class="number">32 </span>+ <span class="number">29</span>);
<span class="doccomment">/// Pending Break Enable. The processor supports the use of the FERR#/PBE# pin when the processor is in the stop-clock state (STPCLK# is asserted) to signal the processor that an interrupt is pending and that the processor should return to normal operation to handle the interrupt. Bit 10 (PBE enable) in the IA32_MISC_ENABLE MSR enables this capability.
</span><span class="kw">const </span>PBE = <span class="number">1 </span>&lt;&lt; (<span class="number">32 </span>+ <span class="number">31</span>);
}
}
<span class="doccomment">/// Iterator over caches (LEAF=0x04).
///
/// Yields a [CacheParameter] for each cache.
///
/// # Platforms
/// 🟡 AMD ✅ Intel
</span><span class="attribute">#[derive(Clone)]
#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, derive(Serialize, Deserialize))]
</span><span class="kw">pub struct </span>CacheParametersIter {
<span class="attribute">#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, serde(skip))]
</span>read: CpuIdReader,
leaf: u32,
current: u32,
}
<span class="kw">impl </span>Iterator <span class="kw">for </span>CacheParametersIter {
<span class="kw">type </span>Item = CacheParameter;
<span class="doccomment">/// Iterate over all cache info subleafs for this CPU.
///
/// # Note
/// cpuid is called every-time we advance the iterator to get information
/// about the next cache.
</span><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;CacheParameter&gt; {
<span class="kw">let </span>res = <span class="self">self</span>.read.cpuid2(<span class="self">self</span>.leaf, <span class="self">self</span>.current);
<span class="kw">let </span>cp = CacheParameter {
eax: res.eax,
ebx: res.ebx,
ecx: res.ecx,
edx: res.edx,
};
<span class="kw">match </span>cp.cache_type() {
CacheType::Null =&gt; <span class="prelude-val">None</span>,
CacheType::Reserved =&gt; <span class="prelude-val">None</span>,
<span class="kw">_ </span>=&gt; {
<span class="self">self</span>.current += <span class="number">1</span>;
<span class="prelude-val">Some</span>(cp)
}
}
}
}
<span class="kw">impl </span>Debug <span class="kw">for </span>CacheParametersIter {
<span class="kw">fn </span>fmt(<span class="kw-2">&amp;</span><span class="self">self</span>, f: <span class="kw-2">&amp;mut </span>Formatter&lt;<span class="lifetime">&#39;_</span>&gt;) -&gt; core::fmt::Result {
<span class="kw">let </span><span class="kw-2">mut </span>debug = f.debug_list();
<span class="self">self</span>.clone().for_each(|<span class="kw-2">ref </span>item| {
debug.entry(item);
});
debug.finish()
}
}
<span class="doccomment">/// Information about an individual cache in the hierarchy.
///
/// # Platforms
/// 🟡 AMD ✅ Intel
</span><span class="attribute">#[derive(Copy, Clone, Eq, PartialEq)]
#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, derive(Serialize, Deserialize))]
</span><span class="kw">pub struct </span>CacheParameter {
eax: u32,
ebx: u32,
ecx: u32,
edx: u32,
}
<span class="doccomment">/// Info about a what a given cache caches (instructions, data, etc.)
</span><span class="attribute">#[derive(PartialEq, Eq, Debug)]
#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, derive(Serialize, Deserialize))]
</span><span class="kw">pub enum </span>CacheType {
<span class="doccomment">/// Null - No more caches
</span>Null = <span class="number">0</span>,
<span class="doccomment">/// Data cache
</span>Data,
<span class="doccomment">/// Instruction cache
</span>Instruction,
<span class="doccomment">/// Data and Instruction cache
</span>Unified,
<span class="doccomment">/// 4-31 = Reserved
</span>Reserved,
}
<span class="kw">impl </span>fmt::Display <span class="kw">for </span>CacheType {
<span class="kw">fn </span>fmt(<span class="kw-2">&amp;</span><span class="self">self</span>, f: <span class="kw-2">&amp;mut </span>fmt::Formatter) -&gt; fmt::Result {
<span class="kw">let </span>typ = <span class="kw">match </span><span class="self">self </span>{
CacheType::Null =&gt; <span class="string">&quot;Null&quot;</span>,
CacheType::Data =&gt; <span class="string">&quot;Data&quot;</span>,
CacheType::Instruction =&gt; <span class="string">&quot;Instruction&quot;</span>,
CacheType::Unified =&gt; <span class="string">&quot;Unified&quot;</span>,
CacheType::Reserved =&gt; <span class="string">&quot;Reserved&quot;</span>,
};
f.write_str(typ)
}
}
<span class="kw">impl </span>CacheParameter {
<span class="doccomment">/// Cache Type
///
/// # Platforms
/// ✅ AMD ✅ Intel
</span><span class="kw">pub fn </span>cache_type(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; CacheType {
<span class="kw">let </span>typ = get_bits(<span class="self">self</span>.eax, <span class="number">0</span>, <span class="number">4</span>) <span class="kw">as </span>u8;
<span class="kw">match </span>typ {
<span class="number">0 </span>=&gt; CacheType::Null,
<span class="number">1 </span>=&gt; CacheType::Data,
<span class="number">2 </span>=&gt; CacheType::Instruction,
<span class="number">3 </span>=&gt; CacheType::Unified,
<span class="kw">_ </span>=&gt; CacheType::Reserved,
}
}
<span class="doccomment">/// Cache Level (starts at 1)
///
/// # Platforms
/// ✅ AMD ✅ Intel
</span><span class="kw">pub fn </span>level(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u8 {
get_bits(<span class="self">self</span>.eax, <span class="number">5</span>, <span class="number">7</span>) <span class="kw">as </span>u8
}
<span class="doccomment">/// Self Initializing cache level (does not need SW initialization).
///
/// # Platforms
/// ✅ AMD ✅ Intel
</span><span class="kw">pub fn </span>is_self_initializing(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
get_bits(<span class="self">self</span>.eax, <span class="number">8</span>, <span class="number">8</span>) == <span class="number">1
</span>}
<span class="doccomment">/// Fully Associative cache
///
/// # Platforms
/// ✅ AMD ✅ Intel
</span><span class="kw">pub fn </span>is_fully_associative(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
get_bits(<span class="self">self</span>.eax, <span class="number">9</span>, <span class="number">9</span>) == <span class="number">1
</span>}
<span class="doccomment">/// Maximum number of addressable IDs for logical processors sharing this cache
///
/// # Platforms
/// ✅ AMD ✅ Intel
</span><span class="kw">pub fn </span>max_cores_for_cache(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; usize {
(get_bits(<span class="self">self</span>.eax, <span class="number">14</span>, <span class="number">25</span>) + <span class="number">1</span>) <span class="kw">as </span>usize
}
<span class="doccomment">/// Maximum number of addressable IDs for processor cores in the physical package
///
/// # Platforms
/// ❌ AMD ✅ Intel
</span><span class="kw">pub fn </span>max_cores_for_package(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; usize {
(get_bits(<span class="self">self</span>.eax, <span class="number">26</span>, <span class="number">31</span>) + <span class="number">1</span>) <span class="kw">as </span>usize
}
<span class="doccomment">/// System Coherency Line Size (Bits 11-00)
///
/// # Platforms
/// ✅ AMD ✅ Intel
</span><span class="kw">pub fn </span>coherency_line_size(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; usize {
(get_bits(<span class="self">self</span>.ebx, <span class="number">0</span>, <span class="number">11</span>) + <span class="number">1</span>) <span class="kw">as </span>usize
}
<span class="doccomment">/// Physical Line partitions (Bits 21-12)
///
/// # Platforms
/// ✅ AMD ✅ Intel
</span><span class="kw">pub fn </span>physical_line_partitions(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; usize {
(get_bits(<span class="self">self</span>.ebx, <span class="number">12</span>, <span class="number">21</span>) + <span class="number">1</span>) <span class="kw">as </span>usize
}
<span class="doccomment">/// Ways of associativity (Bits 31-22)
///
/// # Platforms
/// ✅ AMD ✅ Intel
</span><span class="kw">pub fn </span>associativity(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; usize {
(get_bits(<span class="self">self</span>.ebx, <span class="number">22</span>, <span class="number">31</span>) + <span class="number">1</span>) <span class="kw">as </span>usize
}
<span class="doccomment">/// Number of Sets (Bits 31-00)
///
/// # Platforms
/// ✅ AMD ✅ Intel
</span><span class="kw">pub fn </span>sets(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; usize {
(<span class="self">self</span>.ecx + <span class="number">1</span>) <span class="kw">as </span>usize
}
<span class="doccomment">/// Write-Back Invalidate/Invalidate (Bit 0)
/// False: WBINVD/INVD from threads sharing this cache acts upon lower level caches for threads sharing this cache.
/// True: WBINVD/INVD is not guaranteed to act upon lower level caches of non-originating threads sharing this cache.
///
/// # Platforms
/// ✅ AMD ✅ Intel
</span><span class="kw">pub fn </span>is_write_back_invalidate(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
get_bits(<span class="self">self</span>.edx, <span class="number">0</span>, <span class="number">0</span>) == <span class="number">1
</span>}
<span class="doccomment">/// Cache Inclusiveness (Bit 1)
/// False: Cache is not inclusive of lower cache levels.
/// True: Cache is inclusive of lower cache levels.
///
/// # Platforms
/// ✅ AMD ✅ Intel
</span><span class="kw">pub fn </span>is_inclusive(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
get_bits(<span class="self">self</span>.edx, <span class="number">1</span>, <span class="number">1</span>) == <span class="number">1
</span>}
<span class="doccomment">/// Complex Cache Indexing (Bit 2)
/// False: Direct mapped cache.
/// True: A complex function is used to index the cache, potentially using all address bits.
///
/// # Platforms
/// ❌ AMD ✅ Intel
</span><span class="kw">pub fn </span>has_complex_indexing(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
get_bits(<span class="self">self</span>.edx, <span class="number">2</span>, <span class="number">2</span>) == <span class="number">1
</span>}
}
<span class="kw">impl </span>Debug <span class="kw">for </span>CacheParameter {
<span class="kw">fn </span>fmt(<span class="kw-2">&amp;</span><span class="self">self</span>, f: <span class="kw-2">&amp;mut </span>Formatter&lt;<span class="lifetime">&#39;_</span>&gt;) -&gt; core::fmt::Result {
f.debug_struct(<span class="string">&quot;CacheParameter&quot;</span>)
.field(<span class="string">&quot;cache_type&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.cache_type())
.field(<span class="string">&quot;level&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.level())
.field(<span class="string">&quot;is_self_initializing&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.is_self_initializing())
.field(<span class="string">&quot;is_fully_associative&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.is_fully_associative())
.field(<span class="string">&quot;max_cores_for_cache&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.max_cores_for_cache())
.field(<span class="string">&quot;max_cores_for_package&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.max_cores_for_package())
.field(<span class="string">&quot;coherency_line_size&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.coherency_line_size())
.field(<span class="string">&quot;physical_line_partitions&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.physical_line_partitions())
.field(<span class="string">&quot;associativity&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.associativity())
.field(<span class="string">&quot;sets&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.sets())
.field(<span class="string">&quot;is_write_back_invalidate&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.is_write_back_invalidate())
.field(<span class="string">&quot;is_inclusive&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.is_inclusive())
.field(<span class="string">&quot;has_complex_indexing&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.has_complex_indexing())
.finish()
}
}
<span class="doccomment">/// Information about how monitor/mwait works on this CPU (LEAF=0x05).
///
/// # Platforms
/// 🟡 AMD ✅ Intel
</span><span class="attribute">#[derive(Eq, PartialEq)]
#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, derive(Serialize, Deserialize))]
</span><span class="kw">pub struct </span>MonitorMwaitInfo {
eax: u32,
ebx: u32,
ecx: u32,
edx: u32,
}
<span class="kw">impl </span>MonitorMwaitInfo {
<span class="doccomment">/// Smallest monitor-line size in bytes (default is processor&#39;s monitor granularity)
///
/// # Platforms
/// ✅ AMD ✅ Intel
</span><span class="kw">pub fn </span>smallest_monitor_line(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u16 {
get_bits(<span class="self">self</span>.eax, <span class="number">0</span>, <span class="number">15</span>) <span class="kw">as </span>u16
}
<span class="doccomment">/// Largest monitor-line size in bytes (default is processor&#39;s monitor granularity
///
/// # Platforms
/// ✅ AMD ✅ Intel
</span><span class="kw">pub fn </span>largest_monitor_line(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u16 {
get_bits(<span class="self">self</span>.ebx, <span class="number">0</span>, <span class="number">15</span>) <span class="kw">as </span>u16
}
<span class="doccomment">/// Enumeration of Monitor-Mwait extensions (beyond EAX and EBX registers) supported
///
/// # Platforms
/// ✅ AMD ✅ Intel
</span><span class="kw">pub fn </span>extensions_supported(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
get_bits(<span class="self">self</span>.ecx, <span class="number">0</span>, <span class="number">0</span>) == <span class="number">1
</span>}
<span class="doccomment">/// Supports treating interrupts as break-event for MWAIT, even when interrupts disabled
///
/// # Platforms
/// ✅ AMD ✅ Intel
</span><span class="kw">pub fn </span>interrupts_as_break_event(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
get_bits(<span class="self">self</span>.ecx, <span class="number">1</span>, <span class="number">1</span>) == <span class="number">1
</span>}
<span class="doccomment">/// Number of C0 sub C-states supported using MWAIT (Bits 03 - 00)
///
/// # Platforms
/// ❌ AMD (undefined/reserved) ✅ Intel
</span><span class="kw">pub fn </span>supported_c0_states(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u16 {
get_bits(<span class="self">self</span>.edx, <span class="number">0</span>, <span class="number">3</span>) <span class="kw">as </span>u16
}
<span class="doccomment">/// Number of C1 sub C-states supported using MWAIT (Bits 07 - 04)
///
/// # Platforms
/// ❌ AMD (undefined/reserved) ✅ Intel
</span><span class="kw">pub fn </span>supported_c1_states(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u16 {
get_bits(<span class="self">self</span>.edx, <span class="number">4</span>, <span class="number">7</span>) <span class="kw">as </span>u16
}
<span class="doccomment">/// Number of C2 sub C-states supported using MWAIT (Bits 11 - 08)
///
/// # Platforms
/// ❌ AMD (undefined/reserved) ✅ Intel
</span><span class="kw">pub fn </span>supported_c2_states(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u16 {
get_bits(<span class="self">self</span>.edx, <span class="number">8</span>, <span class="number">11</span>) <span class="kw">as </span>u16
}
<span class="doccomment">/// Number of C3 sub C-states supported using MWAIT (Bits 15 - 12)
///
/// # Platforms
/// ❌ AMD (undefined/reserved) ✅ Intel
</span><span class="kw">pub fn </span>supported_c3_states(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u16 {
get_bits(<span class="self">self</span>.edx, <span class="number">12</span>, <span class="number">15</span>) <span class="kw">as </span>u16
}
<span class="doccomment">/// Number of C4 sub C-states supported using MWAIT (Bits 19 - 16)
///
/// # Platforms
/// ❌ AMD (undefined/reserved) ✅ Intel
</span><span class="kw">pub fn </span>supported_c4_states(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u16 {
get_bits(<span class="self">self</span>.edx, <span class="number">16</span>, <span class="number">19</span>) <span class="kw">as </span>u16
}
<span class="doccomment">/// Number of C5 sub C-states supported using MWAIT (Bits 23 - 20)
///
/// # Platforms
/// ❌ AMD (undefined/reserved) ✅ Intel
</span><span class="kw">pub fn </span>supported_c5_states(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u16 {
get_bits(<span class="self">self</span>.edx, <span class="number">20</span>, <span class="number">23</span>) <span class="kw">as </span>u16
}
<span class="doccomment">/// Number of C6 sub C-states supported using MWAIT (Bits 27 - 24)
///
/// # Platforms
/// ❌ AMD (undefined/reserved) ✅ Intel
</span><span class="kw">pub fn </span>supported_c6_states(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u16 {
get_bits(<span class="self">self</span>.edx, <span class="number">24</span>, <span class="number">27</span>) <span class="kw">as </span>u16
}
<span class="doccomment">/// Number of C7 sub C-states supported using MWAIT (Bits 31 - 28)
///
/// # Platforms
/// ❌ AMD (undefined/reserved) ✅ Intel
</span><span class="kw">pub fn </span>supported_c7_states(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u16 {
get_bits(<span class="self">self</span>.edx, <span class="number">28</span>, <span class="number">31</span>) <span class="kw">as </span>u16
}
}
<span class="kw">impl </span>Debug <span class="kw">for </span>MonitorMwaitInfo {
<span class="kw">fn </span>fmt(<span class="kw-2">&amp;</span><span class="self">self</span>, f: <span class="kw-2">&amp;mut </span>Formatter&lt;<span class="lifetime">&#39;_</span>&gt;) -&gt; core::fmt::Result {
f.debug_struct(<span class="string">&quot;MonitorMwaitInfo&quot;</span>)
.field(<span class="string">&quot;smallest_monitor_line&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.smallest_monitor_line())
.field(<span class="string">&quot;largest_monitor_line&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.largest_monitor_line())
.field(<span class="string">&quot;extensions_supported&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.extensions_supported())
.field(
<span class="string">&quot;interrupts_as_break_event&quot;</span>,
<span class="kw-2">&amp;</span><span class="self">self</span>.interrupts_as_break_event(),
)
.field(<span class="string">&quot;supported_c0_states&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.supported_c0_states())
.field(<span class="string">&quot;supported_c1_states&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.supported_c1_states())
.field(<span class="string">&quot;supported_c2_states&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.supported_c2_states())
.field(<span class="string">&quot;supported_c3_states&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.supported_c3_states())
.field(<span class="string">&quot;supported_c4_states&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.supported_c4_states())
.field(<span class="string">&quot;supported_c5_states&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.supported_c5_states())
.field(<span class="string">&quot;supported_c6_states&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.supported_c6_states())
.field(<span class="string">&quot;supported_c7_states&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.supported_c7_states())
.finish()
}
}
<span class="doccomment">/// Query information about thermal and power management features of the CPU (LEAF=0x06).
///
/// # Platforms
/// 🟡 AMD ✅ Intel
</span><span class="attribute">#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, derive(Serialize, Deserialize))]
</span><span class="kw">pub struct </span>ThermalPowerInfo {
eax: ThermalPowerFeaturesEax,
ebx: u32,
ecx: ThermalPowerFeaturesEcx,
_edx: u32,
}
<span class="kw">impl </span>ThermalPowerInfo {
<span class="doccomment">/// Number of Interrupt Thresholds in Digital Thermal Sensor
///
/// # Platforms
/// ❌ AMD (undefined/reserved) ✅ Intel
</span><span class="kw">pub fn </span>dts_irq_threshold(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u8 {
get_bits(<span class="self">self</span>.ebx, <span class="number">0</span>, <span class="number">3</span>) <span class="kw">as </span>u8
}
<span class="doccomment">/// Digital temperature sensor is supported if set.
///
/// # Platforms
/// ❌ AMD (reserved) ✅ Intel
</span><span class="kw">pub fn </span>has_dts(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.eax.contains(ThermalPowerFeaturesEax::DTS)
}
<span class="doccomment">/// Intel Turbo Boost Technology Available (see description of
/// IA32_MISC_ENABLE\[38\]).
///
/// # Platforms
/// ❌ AMD (reserved) ✅ Intel
</span><span class="kw">pub fn </span>has_turbo_boost(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.eax.contains(ThermalPowerFeaturesEax::TURBO_BOOST)
}
<span class="doccomment">/// ARAT. APIC-Timer-always-running feature is supported if set.
///
/// # Platforms
/// ✅ AMD ✅ Intel
</span><span class="kw">pub fn </span>has_arat(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.eax.contains(ThermalPowerFeaturesEax::ARAT)
}
<span class="doccomment">/// PLN. Power limit notification controls are supported if set.
///
/// # Platforms
/// ❌ AMD (reserved) ✅ Intel
</span><span class="kw">pub fn </span>has_pln(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.eax.contains(ThermalPowerFeaturesEax::PLN)
}
<span class="doccomment">/// ECMD. Clock modulation duty cycle extension is supported if set.
///
/// # Platforms
/// ❌ AMD (reserved) ✅ Intel
</span><span class="kw">pub fn </span>has_ecmd(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.eax.contains(ThermalPowerFeaturesEax::ECMD)
}
<span class="doccomment">/// PTM. Package thermal management is supported if set.
///
/// # Platforms
/// ❌ AMD (reserved) ✅ Intel
</span><span class="kw">pub fn </span>has_ptm(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.eax.contains(ThermalPowerFeaturesEax::PTM)
}
<span class="doccomment">/// HWP. HWP base registers (IA32_PM_ENABLE[bit 0], IA32_HWP_CAPABILITIES,
/// IA32_HWP_REQUEST, IA32_HWP_STATUS) are supported if set.
///
/// # Platforms
/// ❌ AMD (reserved) ✅ Intel
</span><span class="kw">pub fn </span>has_hwp(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.eax.contains(ThermalPowerFeaturesEax::HWP)
}
<span class="doccomment">/// HWP Notification. IA32_HWP_INTERRUPT MSR is supported if set.
///
/// # Platforms
/// ❌ AMD (reserved) ✅ Intel
</span><span class="kw">pub fn </span>has_hwp_notification(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.eax.contains(ThermalPowerFeaturesEax::HWP_NOTIFICATION)
}
<span class="doccomment">/// HWP Activity Window. IA32_HWP_REQUEST[bits 41:32] is supported if set.
///
/// # Platforms
/// ❌ AMD (reserved) ✅ Intel
</span><span class="kw">pub fn </span>has_hwp_activity_window(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.eax
.contains(ThermalPowerFeaturesEax::HWP_ACTIVITY_WINDOW)
}
<span class="doccomment">/// HWP Energy Performance Preference. IA32_HWP_REQUEST[bits 31:24] is
/// supported if set.
///
/// # Platforms
/// ❌ AMD (reserved) ✅ Intel
</span><span class="kw">pub fn </span>has_hwp_energy_performance_preference(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.eax
.contains(ThermalPowerFeaturesEax::HWP_ENERGY_PERFORMANCE_PREFERENCE)
}
<span class="doccomment">/// HWP Package Level Request. IA32_HWP_REQUEST_PKG MSR is supported if set.
///
/// # Platforms
/// ❌ AMD (reserved) ✅ Intel
</span><span class="kw">pub fn </span>has_hwp_package_level_request(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.eax
.contains(ThermalPowerFeaturesEax::HWP_PACKAGE_LEVEL_REQUEST)
}
<span class="doccomment">/// HDC. HDC base registers IA32_PKG_HDC_CTL, IA32_PM_CTL1,
/// IA32_THREAD_STALL MSRs are supported if set.
///
/// # Platforms
/// ❌ AMD (reserved) ✅ Intel
</span><span class="kw">pub fn </span>has_hdc(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.eax.contains(ThermalPowerFeaturesEax::HDC)
}
<span class="doccomment">/// Intel® Turbo Boost Max Technology 3.0 available.
///
/// # Platforms
/// ❌ AMD (reserved) ✅ Intel
</span><span class="kw">pub fn </span>has_turbo_boost3(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.eax.contains(ThermalPowerFeaturesEax::TURBO_BOOST_3)
}
<span class="doccomment">/// HWP Capabilities. Highest Performance change is supported if set.
///
/// # Platforms
/// ❌ AMD (reserved) ✅ Intel
</span><span class="kw">pub fn </span>has_hwp_capabilities(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.eax.contains(ThermalPowerFeaturesEax::HWP_CAPABILITIES)
}
<span class="doccomment">/// HWP PECI override is supported if set.
///
/// # Platforms
/// ❌ AMD (reserved) ✅ Intel
</span><span class="kw">pub fn </span>has_hwp_peci_override(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.eax
.contains(ThermalPowerFeaturesEax::HWP_PECI_OVERRIDE)
}
<span class="doccomment">/// Flexible HWP is supported if set.
///
/// # Platforms
/// ❌ AMD (reserved) ✅ Intel
</span><span class="kw">pub fn </span>has_flexible_hwp(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.eax.contains(ThermalPowerFeaturesEax::FLEXIBLE_HWP)
}
<span class="doccomment">/// Fast access mode for the IA32_HWP_REQUEST MSR is supported if set.
///
/// # Platforms
/// ❌ AMD (reserved) ✅ Intel
</span><span class="kw">pub fn </span>has_hwp_fast_access_mode(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.eax
.contains(ThermalPowerFeaturesEax::HWP_REQUEST_MSR_FAST_ACCESS)
}
<span class="doccomment">/// Ignoring Idle Logical Processor HWP request is supported if set.
///
/// # Platforms
/// ❌ AMD (reserved) ✅ Intel
</span><span class="kw">pub fn </span>has_ignore_idle_processor_hwp_request(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.eax
.contains(ThermalPowerFeaturesEax::IGNORE_IDLE_PROCESSOR_HWP_REQUEST)
}
<span class="doccomment">/// Hardware Coordination Feedback Capability
///
/// Presence of IA32_MPERF and IA32_APERF.
///
/// The capability to provide a measure of delivered processor performance
/// (since last reset of the counters), as a percentage of expected
/// processor performance at frequency specified in CPUID Brand String Bits
/// 02 - 01
///
/// # Platforms
/// ✅ AMD ✅ Intel
</span><span class="kw">pub fn </span>has_hw_coord_feedback(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.ecx
.contains(ThermalPowerFeaturesEcx::HW_COORD_FEEDBACK)
}
<span class="doccomment">/// The processor supports performance-energy bias preference if
/// CPUID.06H:ECX.SETBH[bit 3] is set and it also implies the presence of a
/// new architectural MSR called IA32_ENERGY_PERF_BIAS (1B0H)
///
/// # Platforms
/// ❌ AMD (reserved) ✅ Intel
</span><span class="kw">pub fn </span>has_energy_bias_pref(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.ecx.contains(ThermalPowerFeaturesEcx::ENERGY_BIAS_PREF)
}
}
<span class="kw">impl </span>Debug <span class="kw">for </span>ThermalPowerInfo {
<span class="kw">fn </span>fmt(<span class="kw-2">&amp;</span><span class="self">self</span>, f: <span class="kw-2">&amp;mut </span>Formatter&lt;<span class="lifetime">&#39;_</span>&gt;) -&gt; core::fmt::Result {
f.debug_struct(<span class="string">&quot;ThermalPowerInfo&quot;</span>)
.field(<span class="string">&quot;dts_irq_threshold&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.dts_irq_threshold())
.field(<span class="string">&quot;has_dts&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.has_dts())
.field(<span class="string">&quot;has_arat&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.has_arat())
.field(<span class="string">&quot;has_pln&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.has_pln())
.field(<span class="string">&quot;has_ecmd&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.has_ecmd())
.field(<span class="string">&quot;has_ptm&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.has_ptm())
.field(<span class="string">&quot;has_hwp&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.has_hwp())
.field(<span class="string">&quot;has_hwp_notification&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.has_hwp_notification())
.field(<span class="string">&quot;has_hwp_activity_window&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.has_hwp_activity_window())
.field(
<span class="string">&quot;has_hwp_energy_performance_preference&quot;</span>,
<span class="kw-2">&amp;</span><span class="self">self</span>.has_hwp_energy_performance_preference(),
)
.field(
<span class="string">&quot;has_hwp_package_level_request&quot;</span>,
<span class="kw-2">&amp;</span><span class="self">self</span>.has_hwp_package_level_request(),
)
.field(<span class="string">&quot;has_hdc&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.has_hdc())
.field(<span class="string">&quot;has_turbo_boost3&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.has_turbo_boost3())
.field(<span class="string">&quot;has_hwp_capabilities&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.has_hwp_capabilities())
.field(<span class="string">&quot;has_hwp_peci_override&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.has_hwp_peci_override())
.field(<span class="string">&quot;has_flexible_hwp&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.has_flexible_hwp())
.field(<span class="string">&quot;has_hwp_fast_access_mode&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.has_hwp_fast_access_mode())
.field(
<span class="string">&quot;has_ignore_idle_processor_hwp_request&quot;</span>,
<span class="kw-2">&amp;</span><span class="self">self</span>.has_ignore_idle_processor_hwp_request(),
)
.field(<span class="string">&quot;has_hw_coord_feedback&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.has_hw_coord_feedback())
.field(<span class="string">&quot;has_energy_bias_pref&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.has_energy_bias_pref())
.finish()
}
}
<span class="macro">bitflags! </span>{
<span class="attribute">#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, derive(Serialize, Deserialize))]
</span><span class="kw">struct </span>ThermalPowerFeaturesEax: u32 {
<span class="doccomment">/// Digital temperature sensor is supported if set. (Bit 00)
</span><span class="kw">const </span>DTS = <span class="number">1 </span>&lt;&lt; <span class="number">0</span>;
<span class="doccomment">/// Intel Turbo Boost Technology Available (see description of IA32_MISC_ENABLE[38]). (Bit 01)
</span><span class="kw">const </span>TURBO_BOOST = <span class="number">1 </span>&lt;&lt; <span class="number">1</span>;
<span class="doccomment">/// ARAT. APIC-Timer-always-running feature is supported if set. (Bit 02)
</span><span class="kw">const </span>ARAT = <span class="number">1 </span>&lt;&lt; <span class="number">2</span>;
<span class="doccomment">/// Bit 3: Reserved.
</span><span class="kw">const </span>RESERVED_3 = <span class="number">1 </span>&lt;&lt; <span class="number">3</span>;
<span class="doccomment">/// PLN. Power limit notification controls are supported if set. (Bit 04)
</span><span class="kw">const </span>PLN = <span class="number">1 </span>&lt;&lt; <span class="number">4</span>;
<span class="doccomment">/// ECMD. Clock modulation duty cycle extension is supported if set. (Bit 05)
</span><span class="kw">const </span>ECMD = <span class="number">1 </span>&lt;&lt; <span class="number">5</span>;
<span class="doccomment">/// PTM. Package thermal management is supported if set. (Bit 06)
</span><span class="kw">const </span>PTM = <span class="number">1 </span>&lt;&lt; <span class="number">6</span>;
<span class="doccomment">/// Bit 07: HWP. HWP base registers (IA32_PM_ENABLE[bit 0], IA32_HWP_CAPABILITIES, IA32_HWP_REQUEST, IA32_HWP_STATUS) are supported if set.
</span><span class="kw">const </span>HWP = <span class="number">1 </span>&lt;&lt; <span class="number">7</span>;
<span class="doccomment">/// Bit 08: HWP_Notification. IA32_HWP_INTERRUPT MSR is supported if set.
</span><span class="kw">const </span>HWP_NOTIFICATION = <span class="number">1 </span>&lt;&lt; <span class="number">8</span>;
<span class="doccomment">/// Bit 09: HWP_Activity_Window. IA32_HWP_REQUEST[bits 41:32] is supported if set.
</span><span class="kw">const </span>HWP_ACTIVITY_WINDOW = <span class="number">1 </span>&lt;&lt; <span class="number">9</span>;
<span class="doccomment">/// Bit 10: HWP_Energy_Performance_Preference. IA32_HWP_REQUEST[bits 31:24] is supported if set.
</span><span class="kw">const </span>HWP_ENERGY_PERFORMANCE_PREFERENCE = <span class="number">1 </span>&lt;&lt; <span class="number">10</span>;
<span class="doccomment">/// Bit 11: HWP_Package_Level_Request. IA32_HWP_REQUEST_PKG MSR is supported if set.
</span><span class="kw">const </span>HWP_PACKAGE_LEVEL_REQUEST = <span class="number">1 </span>&lt;&lt; <span class="number">11</span>;
<span class="doccomment">/// Bit 12: Reserved.
</span><span class="kw">const </span>RESERVED_12 = <span class="number">1 </span>&lt;&lt; <span class="number">12</span>;
<span class="doccomment">/// Bit 13: HDC. HDC base registers IA32_PKG_HDC_CTL, IA32_PM_CTL1, IA32_THREAD_STALL MSRs are supported if set.
</span><span class="kw">const </span>HDC = <span class="number">1 </span>&lt;&lt; <span class="number">13</span>;
<span class="doccomment">/// Bit 14: Intel® Turbo Boost Max Technology 3.0 available.
</span><span class="kw">const </span>TURBO_BOOST_3 = <span class="number">1 </span>&lt;&lt; <span class="number">14</span>;
<span class="doccomment">/// Bit 15: HWP Capabilities. Highest Performance change is supported if set.
</span><span class="kw">const </span>HWP_CAPABILITIES = <span class="number">1 </span>&lt;&lt; <span class="number">15</span>;
<span class="doccomment">/// Bit 16: HWP PECI override is supported if set.
</span><span class="kw">const </span>HWP_PECI_OVERRIDE = <span class="number">1 </span>&lt;&lt; <span class="number">16</span>;
<span class="doccomment">/// Bit 17: Flexible HWP is supported if set.
</span><span class="kw">const </span>FLEXIBLE_HWP = <span class="number">1 </span>&lt;&lt; <span class="number">17</span>;
<span class="doccomment">/// Bit 18: Fast access mode for the IA32_HWP_REQUEST MSR is supported if set.
</span><span class="kw">const </span>HWP_REQUEST_MSR_FAST_ACCESS = <span class="number">1 </span>&lt;&lt; <span class="number">18</span>;
<span class="doccomment">/// Bit 19: Reserved.
</span><span class="kw">const </span>RESERVED_19 = <span class="number">1 </span>&lt;&lt; <span class="number">19</span>;
<span class="doccomment">/// Bit 20: Ignoring Idle Logical Processor HWP request is supported if set.
</span><span class="kw">const </span>IGNORE_IDLE_PROCESSOR_HWP_REQUEST = <span class="number">1 </span>&lt;&lt; <span class="number">20</span>;
<span class="comment">// Bits 31 - 21: Reserved
</span>}
}
<span class="macro">bitflags! </span>{
<span class="attribute">#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, derive(Serialize, Deserialize))]
</span><span class="kw">struct </span>ThermalPowerFeaturesEcx: u32 {
<span class="kw">const </span>HW_COORD_FEEDBACK = <span class="number">1 </span>&lt;&lt; <span class="number">0</span>;
<span class="doccomment">/// The processor supports performance-energy bias preference if CPUID.06H:ECX.SETBH[bit 3] is set and it also implies the presence of a new architectural MSR called IA32_ENERGY_PERF_BIAS (1B0H)
</span><span class="kw">const </span>ENERGY_BIAS_PREF = <span class="number">1 </span>&lt;&lt; <span class="number">3</span>;
}
}
<span class="doccomment">/// Structured Extended Feature Identifiers (LEAF=0x07).
///
/// # Platforms
/// 🟡 AMD ✅ Intel
</span><span class="attribute">#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, derive(Serialize, Deserialize))]
</span><span class="kw">pub struct </span>ExtendedFeatures {
_eax: u32,
ebx: ExtendedFeaturesEbx,
ecx: ExtendedFeaturesEcx,
_edx: u32,
}
<span class="kw">impl </span>ExtendedFeatures {
<span class="doccomment">/// FSGSBASE. Supports RDFSBASE/RDGSBASE/WRFSBASE/WRGSBASE if 1.
///
/// # Platforms
/// ✅ AMD ✅ Intel
</span><span class="attribute">#[inline]
</span><span class="kw">pub const fn </span>has_fsgsbase(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.ebx.contains(ExtendedFeaturesEbx::FSGSBASE)
}
<span class="doccomment">/// IA32_TSC_ADJUST MSR is supported if 1.
///
/// # Platforms
/// ❌ AMD (reserved) ✅ Intel
</span><span class="attribute">#[inline]
</span><span class="kw">pub const fn </span>has_tsc_adjust_msr(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.ebx.contains(ExtendedFeaturesEbx::ADJUST_MSR)
}
<span class="doccomment">/// BMI1
///
/// # Platforms
/// ✅ AMD ✅ Intel
</span><span class="attribute">#[inline]
</span><span class="kw">pub const fn </span>has_bmi1(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.ebx.contains(ExtendedFeaturesEbx::BMI1)
}
<span class="doccomment">/// HLE
///
/// # Platforms
/// ❌ AMD (reserved) ✅ Intel
</span><span class="attribute">#[inline]
</span><span class="kw">pub const fn </span>has_hle(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.ebx.contains(ExtendedFeaturesEbx::HLE)
}
<span class="doccomment">/// AVX2
///
/// # Platforms
/// ✅ AMD ✅ Intel
</span><span class="attribute">#[inline]
</span><span class="kw">pub const fn </span>has_avx2(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.ebx.contains(ExtendedFeaturesEbx::AVX2)
}
<span class="doccomment">/// FDP_EXCPTN_ONLY. x87 FPU Data Pointer updated only on x87 exceptions if
/// 1.
///
/// # Platforms
/// ❌ AMD (reserved) ✅ Intel
</span><span class="attribute">#[inline]
</span><span class="kw">pub const fn </span>has_fdp(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.ebx.contains(ExtendedFeaturesEbx::FDP)
}
<span class="doccomment">/// SMEP. Supports Supervisor-Mode Execution Prevention if 1.
///
/// # Platforms
/// ✅ AMD ✅ Intel
</span><span class="attribute">#[inline]
</span><span class="kw">pub const fn </span>has_smep(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.ebx.contains(ExtendedFeaturesEbx::SMEP)
}
<span class="doccomment">/// BMI2
///
/// # Platforms
/// ✅ AMD ✅ Intel
</span><span class="attribute">#[inline]
</span><span class="kw">pub const fn </span>has_bmi2(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.ebx.contains(ExtendedFeaturesEbx::BMI2)
}
<span class="doccomment">/// Supports Enhanced REP MOVSB/STOSB if 1.
///
/// # Platforms
/// ❌ AMD (reserved) ✅ Intel
</span><span class="attribute">#[inline]
</span><span class="kw">pub const fn </span>has_rep_movsb_stosb(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.ebx.contains(ExtendedFeaturesEbx::REP_MOVSB_STOSB)
}
<span class="doccomment">/// INVPCID. If 1, supports INVPCID instruction for system software that
/// manages process-context identifiers.
///
/// # Platforms
/// ❌ AMD (reserved) ✅ Intel
</span><span class="attribute">#[inline]
</span><span class="kw">pub const fn </span>has_invpcid(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.ebx.contains(ExtendedFeaturesEbx::INVPCID)
}
<span class="doccomment">/// RTM
///
/// # Platforms
/// ❌ AMD (reserved) ✅ Intel
</span><span class="attribute">#[inline]
</span><span class="kw">pub const fn </span>has_rtm(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.ebx.contains(ExtendedFeaturesEbx::RTM)
}
<span class="doccomment">/// Supports Intel Resource Director Technology (RDT) Monitoring capability.
///
/// # Platforms
/// ❌ AMD (reserved) ✅ Intel
</span><span class="attribute">#[inline]
</span><span class="kw">pub const fn </span>has_rdtm(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.ebx.contains(ExtendedFeaturesEbx::RDTM)
}
<span class="doccomment">/// Deprecates FPU CS and FPU DS values if 1.
///
/// # Platforms
/// ❌ AMD (reserved) ✅ Intel
</span><span class="attribute">#[inline]
</span><span class="kw">pub const fn </span>has_fpu_cs_ds_deprecated(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.ebx.contains(ExtendedFeaturesEbx::DEPRECATE_FPU_CS_DS)
}
<span class="doccomment">/// MPX. Supports Intel Memory Protection Extensions if 1.
///
/// # Platforms
/// ❌ AMD (reserved) ✅ Intel
</span><span class="attribute">#[inline]
</span><span class="kw">pub const fn </span>has_mpx(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.ebx.contains(ExtendedFeaturesEbx::MPX)
}
<span class="doccomment">/// Supports Intel Resource Director Technology (RDT) Allocation capability.
///
/// # Platforms
/// ❌ AMD (reserved) ✅ Intel
</span><span class="attribute">#[inline]
</span><span class="kw">pub const fn </span>has_rdta(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.ebx.contains(ExtendedFeaturesEbx::RDTA)
}
<span class="doccomment">/// Supports RDSEED.
///
/// # Platforms
/// ✅ AMD ✅ Intel
</span><span class="attribute">#[inline]
</span><span class="kw">pub const fn </span>has_rdseed(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.ebx.contains(ExtendedFeaturesEbx::RDSEED)
}
<span class="doccomment">/// Supports ADX.
///
/// # Platforms
/// ✅ AMD ✅ Intel
</span><span class="attribute">#[inline]
</span><span class="kw">pub const fn </span>has_adx(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.ebx.contains(ExtendedFeaturesEbx::ADX)
}
<span class="doccomment">/// SMAP. Supports Supervisor-Mode Access Prevention (and the CLAC/STAC
/// instructions) if 1.
///
/// # Platforms
/// ✅ AMD ✅ Intel
</span><span class="attribute">#[inline]
</span><span class="kw">pub const fn </span>has_smap(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.ebx.contains(ExtendedFeaturesEbx::SMAP)
}
<span class="doccomment">/// Supports CLFLUSHOPT.
///
/// # Platforms
/// ✅ AMD ✅ Intel
</span><span class="attribute">#[inline]
</span><span class="kw">pub const fn </span>has_clflushopt(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.ebx.contains(ExtendedFeaturesEbx::CLFLUSHOPT)
}
<span class="doccomment">/// Supports Intel Processor Trace.
///
/// # Platforms
/// ❌ AMD (reserved) ✅ Intel
</span><span class="attribute">#[inline]
</span><span class="kw">pub const fn </span>has_processor_trace(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.ebx.contains(ExtendedFeaturesEbx::PROCESSOR_TRACE)
}
<span class="doccomment">/// Supports SHA Instructions.
///
/// # Platforms
/// ❌ AMD (reserved) ✅ Intel
</span><span class="attribute">#[inline]
</span><span class="kw">pub const fn </span>has_sha(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.ebx.contains(ExtendedFeaturesEbx::SHA)
}
<span class="doccomment">/// Supports Intel® Software Guard Extensions (Intel® SGX Extensions).
///
/// # Platforms
/// ❌ AMD (reserved) ✅ Intel
</span><span class="attribute">#[inline]
</span><span class="kw">pub const fn </span>has_sgx(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.ebx.contains(ExtendedFeaturesEbx::SGX)
}
<span class="doccomment">/// Supports AVX512F.
///
/// # Platforms
/// ❌ AMD (reserved) ✅ Intel
</span><span class="attribute">#[inline]
</span><span class="kw">pub const fn </span>has_avx512f(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.ebx.contains(ExtendedFeaturesEbx::AVX512F)
}
<span class="doccomment">/// Supports AVX512DQ.
///
/// # Platforms
/// ❌ AMD (reserved) ✅ Intel
</span><span class="attribute">#[inline]
</span><span class="kw">pub const fn </span>has_avx512dq(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.ebx.contains(ExtendedFeaturesEbx::AVX512DQ)
}
<span class="doccomment">/// AVX512_IFMA
///
/// # Platforms
/// ❌ AMD (reserved) ✅ Intel
</span><span class="attribute">#[inline]
</span><span class="kw">pub const fn </span>has_avx512_ifma(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.ebx.contains(ExtendedFeaturesEbx::AVX512_IFMA)
}
<span class="doccomment">/// AVX512PF
///
/// # Platforms
/// ❌ AMD (reserved) ✅ Intel
</span><span class="attribute">#[inline]
</span><span class="kw">pub const fn </span>has_avx512pf(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.ebx.contains(ExtendedFeaturesEbx::AVX512PF)
}
<span class="doccomment">/// AVX512ER
///
/// # Platforms
/// ❌ AMD (reserved) ✅ Intel
</span><span class="attribute">#[inline]
</span><span class="kw">pub const fn </span>has_avx512er(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.ebx.contains(ExtendedFeaturesEbx::AVX512ER)
}
<span class="doccomment">/// AVX512CD
///
/// # Platforms
/// ❌ AMD (reserved) ✅ Intel
</span><span class="attribute">#[inline]
</span><span class="kw">pub const fn </span>has_avx512cd(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.ebx.contains(ExtendedFeaturesEbx::AVX512CD)
}
<span class="doccomment">/// AVX512BW
///
/// # Platforms
/// ❌ AMD (reserved) ✅ Intel
</span><span class="attribute">#[inline]
</span><span class="kw">pub const fn </span>has_avx512bw(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.ebx.contains(ExtendedFeaturesEbx::AVX512BW)
}
<span class="doccomment">/// AVX512VL
///
/// # Platforms
/// ❌ AMD (reserved) ✅ Intel
</span><span class="attribute">#[inline]
</span><span class="kw">pub const fn </span>has_avx512vl(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.ebx.contains(ExtendedFeaturesEbx::AVX512VL)
}
<span class="doccomment">/// CLWB
///
/// # Platforms
/// ✅ AMD ✅ Intel
</span><span class="attribute">#[inline]
</span><span class="kw">pub const fn </span>has_clwb(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.ebx.contains(ExtendedFeaturesEbx::CLWB)
}
<span class="doccomment">/// Has PREFETCHWT1 (Intel® Xeon Phi™ only).
///
/// # Platforms
/// ❌ AMD (reserved) ✅ Intel
</span><span class="attribute">#[inline]
</span><span class="kw">pub const fn </span>has_prefetchwt1(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.ecx.contains(ExtendedFeaturesEcx::PREFETCHWT1)
}
<span class="doccomment">/// Supports user-mode instruction prevention if 1.
///
/// # Platforms
/// ❌ AMD (reserved) ✅ Intel
</span><span class="attribute">#[inline]
</span><span class="kw">pub const fn </span>has_umip(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.ecx.contains(ExtendedFeaturesEcx::UMIP)
}
<span class="doccomment">/// Supports protection keys for user-mode pages.
///
/// # Platforms
/// ❌ AMD (reserved) ✅ Intel
</span><span class="attribute">#[inline]
</span><span class="kw">pub const fn </span>has_pku(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.ecx.contains(ExtendedFeaturesEcx::PKU)
}
<span class="doccomment">/// OS has set CR4.PKE to enable protection keys (and the RDPKRU/WRPKRU
/// instructions.
///
/// # Platforms
/// ❌ AMD (reserved) ✅ Intel
</span><span class="attribute">#[inline]
</span><span class="kw">pub const fn </span>has_ospke(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.ecx.contains(ExtendedFeaturesEcx::OSPKE)
}
<span class="doccomment">/// WAITPKG
///
/// ❓ AMD ✅ Intel
</span><span class="attribute">#[inline]
</span><span class="kw">pub const fn </span>has_waitpkg(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.ecx.contains(ExtendedFeaturesEcx::WAITPKG)
}
<span class="doccomment">/// AVX512VBMI2
///
/// ❓ AMD ✅ Intel
</span><span class="attribute">#[inline]
</span><span class="kw">pub const fn </span>has_av512vbmi2(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.ecx.contains(ExtendedFeaturesEcx::AVX512VBMI2)
}
<span class="doccomment">/// Supports CET shadow stack features. Processors that set this bit define bits 0..2 of the
/// IA32_U_CET and IA32_S_CET MSRs. Enumerates support for the following MSRs:
/// IA32_INTERRUPT_SPP_TABLE_ADDR, IA32_PL3_SSP, IA32_PL2_SSP, IA32_PL1_SSP, and IA32_PL0_SSP.
///
/// ❓ AMD ✅ Intel
</span><span class="attribute">#[inline]
</span><span class="kw">pub const fn </span>has_cet_ss(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.ecx.contains(ExtendedFeaturesEcx::GFNI)
}
<span class="doccomment">/// GFNI
///
/// ❓ AMD ✅ Intel
</span><span class="attribute">#[inline]
</span><span class="kw">pub const fn </span>has_gfni(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.ecx.contains(ExtendedFeaturesEcx::GFNI)
}
<span class="doccomment">/// VAES
///
/// ❓ AMD ✅ Intel
</span><span class="attribute">#[inline]
</span><span class="kw">pub const fn </span>has_vaes(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.ecx.contains(ExtendedFeaturesEcx::VAES)
}
<span class="doccomment">/// VPCLMULQDQ
///
/// ❓ AMD ✅ Intel
</span><span class="attribute">#[inline]
</span><span class="kw">pub const fn </span>has_vpclmulqdq(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.ecx.contains(ExtendedFeaturesEcx::VPCLMULQDQ)
}
<span class="doccomment">/// AVX512VNNI
///
/// # Platforms
/// ❌ AMD (reserved) ✅ Intel
</span><span class="attribute">#[inline]
</span><span class="kw">pub const fn </span>has_avx512vnni(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.ecx.contains(ExtendedFeaturesEcx::AVX512VNNI)
}
<span class="doccomment">/// AVX512BITALG
///
/// ❓ AMD ✅ Intel
</span><span class="attribute">#[inline]
</span><span class="kw">pub const fn </span>has_avx512bitalg(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.ecx.contains(ExtendedFeaturesEcx::AVX512BITALG)
}
<span class="doccomment">/// Indicates the following MSRs are supported: IA32_TME_CAPABILITY, IA32_TME_ACTIVATE,
/// IA32_TME_EXCLUDE_MASK, and IA32_TME_EXCLUDE_BASE.
///
/// ❓ AMD ✅ Intel
</span><span class="attribute">#[inline]
</span><span class="kw">pub const fn </span>has_tme_en(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.ecx.contains(ExtendedFeaturesEcx::TMEEN)
}
<span class="doccomment">/// AVX512VPOPCNTDQ
///
/// ❓ AMD ✅ Intel
</span><span class="attribute">#[inline]
</span><span class="kw">pub const fn </span>has_avx512vpopcntdq(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.ecx.contains(ExtendedFeaturesEcx::AVX512VPOPCNTDQ)
}
<span class="doccomment">/// Supports 57-bit linear addresses and five-level paging if 1.
///
/// # Platforms
/// ❓ AMD ✅ Intel
</span><span class="attribute">#[inline]
</span><span class="kw">pub const fn </span>has_la57(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.ecx.contains(ExtendedFeaturesEcx::LA57)
}
<span class="doccomment">/// RDPID and IA32_TSC_AUX are available.
///
/// # Bug
/// The Intel manual lists RDPID as bit 22 in the ECX register, but AMD
/// lists it as bit 22 in the ebx register. We assumed that the AMD manual
/// was wrong and query ecx, let&#39;s see what happens.
///
/// # Platforms
/// ✅ AMD ✅ Intel
</span><span class="attribute">#[inline]
</span><span class="kw">pub const fn </span>has_rdpid(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.ecx.contains(ExtendedFeaturesEcx::RDPID)
}
<span class="doccomment">/// Supports SGX Launch Configuration.
///
/// # Platforms
/// ❌ AMD (reserved) ✅ Intel
</span><span class="attribute">#[inline]
</span><span class="kw">pub const fn </span>has_sgx_lc(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.ecx.contains(ExtendedFeaturesEcx::SGX_LC)
}
<span class="doccomment">/// The value of MAWAU used by the BNDLDX and BNDSTX instructions in 64-bit mode.
///
/// # Platforms
/// ❌ AMD (reserved) ✅ Intel
</span><span class="attribute">#[inline]
</span><span class="kw">pub fn </span>mawau_value(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u8 {
get_bits(<span class="self">self</span>.ecx.bits(), <span class="number">17</span>, <span class="number">21</span>) <span class="kw">as </span>u8
}
}
<span class="kw">impl </span>Debug <span class="kw">for </span>ExtendedFeatures {
<span class="kw">fn </span>fmt(<span class="kw-2">&amp;</span><span class="self">self</span>, f: <span class="kw-2">&amp;mut </span>Formatter&lt;<span class="lifetime">&#39;_</span>&gt;) -&gt; core::fmt::Result {
f.debug_struct(<span class="string">&quot;ExtendedFeatures&quot;</span>)
.field(<span class="string">&quot;ebx&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.ebx)
.field(<span class="string">&quot;ecx&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.ecx)
.field(<span class="string">&quot;mawau_value&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.mawau_value())
.finish()
}
}
<span class="macro">bitflags! </span>{
<span class="attribute">#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, derive(Serialize, Deserialize))]
</span><span class="kw">struct </span>ExtendedFeaturesEbx: u32 {
<span class="doccomment">/// FSGSBASE. Supports RDFSBASE/RDGSBASE/WRFSBASE/WRGSBASE if 1. (Bit 00)
</span><span class="kw">const </span>FSGSBASE = <span class="number">1 </span>&lt;&lt; <span class="number">0</span>;
<span class="doccomment">/// IA32_TSC_ADJUST MSR is supported if 1. (Bit 01)
</span><span class="kw">const </span>ADJUST_MSR = <span class="number">1 </span>&lt;&lt; <span class="number">1</span>;
<span class="doccomment">/// Bit 02: SGX. Supports Intel® Software Guard Extensions (Intel® SGX Extensions) if 1.
</span><span class="kw">const </span>SGX = <span class="number">1 </span>&lt;&lt; <span class="number">2</span>;
<span class="doccomment">/// BMI1 (Bit 03)
</span><span class="kw">const </span>BMI1 = <span class="number">1 </span>&lt;&lt; <span class="number">3</span>;
<span class="doccomment">/// HLE (Bit 04)
</span><span class="kw">const </span>HLE = <span class="number">1 </span>&lt;&lt; <span class="number">4</span>;
<span class="doccomment">/// AVX2 (Bit 05)
</span><span class="kw">const </span>AVX2 = <span class="number">1 </span>&lt;&lt; <span class="number">5</span>;
<span class="doccomment">/// FDP_EXCPTN_ONLY. x87 FPU Data Pointer updated only on x87 exceptions if 1.
</span><span class="kw">const </span>FDP = <span class="number">1 </span>&lt;&lt; <span class="number">6</span>;
<span class="doccomment">/// SMEP. Supports Supervisor-Mode Execution Prevention if 1. (Bit 07)
</span><span class="kw">const </span>SMEP = <span class="number">1 </span>&lt;&lt; <span class="number">7</span>;
<span class="doccomment">/// BMI2 (Bit 08)
</span><span class="kw">const </span>BMI2 = <span class="number">1 </span>&lt;&lt; <span class="number">8</span>;
<span class="doccomment">/// Supports Enhanced REP MOVSB/STOSB if 1. (Bit 09)
</span><span class="kw">const </span>REP_MOVSB_STOSB = <span class="number">1 </span>&lt;&lt; <span class="number">9</span>;
<span class="doccomment">/// INVPCID. If 1, supports INVPCID instruction for system software that manages process-context identifiers. (Bit 10)
</span><span class="kw">const </span>INVPCID = <span class="number">1 </span>&lt;&lt; <span class="number">10</span>;
<span class="doccomment">/// RTM (Bit 11)
</span><span class="kw">const </span>RTM = <span class="number">1 </span>&lt;&lt; <span class="number">11</span>;
<span class="doccomment">/// Supports Intel Resource Director Technology (RDT) Monitoring. (Bit 12)
</span><span class="kw">const </span>RDTM = <span class="number">1 </span>&lt;&lt; <span class="number">12</span>;
<span class="doccomment">/// Deprecates FPU CS and FPU DS values if 1. (Bit 13)
</span><span class="kw">const </span>DEPRECATE_FPU_CS_DS = <span class="number">1 </span>&lt;&lt; <span class="number">13</span>;
<span class="doccomment">/// Deprecates FPU CS and FPU DS values if 1. (Bit 14)
</span><span class="kw">const </span>MPX = <span class="number">1 </span>&lt;&lt; <span class="number">14</span>;
<span class="doccomment">/// Supports Intel Resource Director Technology (RDT) Allocation capability if 1.
</span><span class="kw">const </span>RDTA = <span class="number">1 </span>&lt;&lt; <span class="number">15</span>;
<span class="doccomment">/// Bit 16: AVX512F.
</span><span class="kw">const </span>AVX512F = <span class="number">1 </span>&lt;&lt; <span class="number">16</span>;
<span class="doccomment">/// Bit 17: AVX512DQ.
</span><span class="kw">const </span>AVX512DQ = <span class="number">1 </span>&lt;&lt; <span class="number">17</span>;
<span class="doccomment">/// Supports RDSEED.
</span><span class="kw">const </span>RDSEED = <span class="number">1 </span>&lt;&lt; <span class="number">18</span>;
<span class="doccomment">/// Supports ADX.
</span><span class="kw">const </span>ADX = <span class="number">1 </span>&lt;&lt; <span class="number">19</span>;
<span class="doccomment">/// SMAP. Supports Supervisor-Mode Access Prevention (and the CLAC/STAC instructions) if 1.
</span><span class="kw">const </span>SMAP = <span class="number">1 </span>&lt;&lt; <span class="number">20</span>;
<span class="doccomment">/// Bit 21: AVX512_IFMA.
</span><span class="kw">const </span>AVX512_IFMA = <span class="number">1 </span>&lt;&lt; <span class="number">21</span>;
<span class="comment">// Bit 22: Reserved.
</span><span class="doccomment">/// Bit 23: CLFLUSHOPT
</span><span class="kw">const </span>CLFLUSHOPT = <span class="number">1 </span>&lt;&lt; <span class="number">23</span>;
<span class="doccomment">/// Bit 24: CLWB.
</span><span class="kw">const </span>CLWB = <span class="number">1 </span>&lt;&lt; <span class="number">24</span>;
<span class="doccomment">/// Bit 25: Intel Processor Trace
</span><span class="kw">const </span>PROCESSOR_TRACE = <span class="number">1 </span>&lt;&lt; <span class="number">25</span>;
<span class="doccomment">/// Bit 26: AVX512PF. (Intel® Xeon Phi™ only.)
</span><span class="kw">const </span>AVX512PF = <span class="number">1 </span>&lt;&lt; <span class="number">26</span>;
<span class="doccomment">/// Bit 27: AVX512ER. (Intel® Xeon Phi™ only.)
</span><span class="kw">const </span>AVX512ER = <span class="number">1 </span>&lt;&lt; <span class="number">27</span>;
<span class="doccomment">/// Bit 28: AVX512CD.
</span><span class="kw">const </span>AVX512CD = <span class="number">1 </span>&lt;&lt; <span class="number">28</span>;
<span class="doccomment">/// Bit 29: Intel SHA Extensions
</span><span class="kw">const </span>SHA = <span class="number">1 </span>&lt;&lt; <span class="number">29</span>;
<span class="doccomment">/// Bit 30: AVX512BW.
</span><span class="kw">const </span>AVX512BW = <span class="number">1 </span>&lt;&lt; <span class="number">30</span>;
<span class="doccomment">/// Bit 31: AVX512VL.
</span><span class="kw">const </span>AVX512VL = <span class="number">1 </span>&lt;&lt; <span class="number">31</span>;
}
}
<span class="macro">bitflags! </span>{
<span class="attribute">#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, derive(Serialize, Deserialize))]
</span><span class="kw">struct </span>ExtendedFeaturesEcx: u32 {
<span class="doccomment">/// Bit 0: Prefetch WT1. (Intel® Xeon Phi™ only).
</span><span class="kw">const </span>PREFETCHWT1 = <span class="number">1 </span>&lt;&lt; <span class="number">0</span>;
<span class="comment">// Bit 01: AVX512_VBMI
</span><span class="kw">const </span>AVX512VBMI = <span class="number">1 </span>&lt;&lt; <span class="number">1</span>;
<span class="doccomment">/// Bit 02: UMIP. Supports user-mode instruction prevention if 1.
</span><span class="kw">const </span>UMIP = <span class="number">1 </span>&lt;&lt; <span class="number">2</span>;
<span class="doccomment">/// Bit 03: PKU. Supports protection keys for user-mode pages if 1.
</span><span class="kw">const </span>PKU = <span class="number">1 </span>&lt;&lt; <span class="number">3</span>;
<span class="doccomment">/// Bit 04: OSPKE. If 1, OS has set CR4.PKE to enable protection keys (and the RDPKRU/WRPKRU instruc-tions).
</span><span class="kw">const </span>OSPKE = <span class="number">1 </span>&lt;&lt; <span class="number">4</span>;
<span class="doccomment">/// Bit 5: WAITPKG
</span><span class="kw">const </span>WAITPKG = <span class="number">1 </span>&gt;&gt; <span class="number">5</span>;
<span class="doccomment">/// Bit 6: AV512_VBMI2
</span><span class="kw">const </span>AVX512VBMI2 = <span class="number">1 </span>&lt;&lt; <span class="number">6</span>;
<span class="doccomment">/// Bit 7: CET_SS. Supports CET shadow stack features if 1. Processors that set this bit define bits 0..2 of the
/// IA32_U_CET and IA32_S_CET MSRs. Enumerates support for the following MSRs:
/// IA32_INTERRUPT_SPP_TABLE_ADDR, IA32_PL3_SSP, IA32_PL2_SSP, IA32_PL1_SSP, and IA32_PL0_SSP.
</span><span class="kw">const </span>CETSS = <span class="number">1 </span>&lt;&lt; <span class="number">7</span>;
<span class="doccomment">/// Bit 8: GFNI
</span><span class="kw">const </span>GFNI = <span class="number">1 </span>&lt;&lt; <span class="number">8</span>;
<span class="doccomment">/// Bit 9: VAES
</span><span class="kw">const </span>VAES = <span class="number">1 </span>&lt;&lt; <span class="number">9</span>;
<span class="doccomment">/// Bit 10: VPCLMULQDQ
</span><span class="kw">const </span>VPCLMULQDQ = <span class="number">1 </span>&lt;&lt; <span class="number">10</span>;
<span class="doccomment">/// Bit 11: AVX512_VNNI
</span><span class="kw">const </span>AVX512VNNI = <span class="number">1 </span>&lt;&lt; <span class="number">11</span>;
<span class="doccomment">/// Bit 12: AVX512_BITALG
</span><span class="kw">const </span>AVX512BITALG = <span class="number">1 </span>&lt;&lt; <span class="number">12</span>;
<span class="doccomment">/// Bit 13: TME_EN. If 1, the following MSRs are supported: IA32_TME_CAPABILITY, IA32_TME_ACTIVATE,
/// IA32_TME_EXCLUDE_MASK, and IA32_TME_EXCLUDE_BASE.
</span><span class="kw">const </span>TMEEN = <span class="number">1 </span>&lt;&lt; <span class="number">13</span>;
<span class="doccomment">/// Bit 14: AVX512_VPOPCNTDQ
</span><span class="kw">const </span>AVX512VPOPCNTDQ = <span class="number">1 </span>&lt;&lt; <span class="number">14</span>;
<span class="comment">// Bit 15: Reserved.
</span><span class="doccomment">/// Bit 16: Supports 57-bit linear addresses and five-level paging if 1.
</span><span class="kw">const </span>LA57 = <span class="number">1 </span>&lt;&lt; <span class="number">16</span>;
<span class="comment">// Bits 21 - 17: The value of MAWAU used by the BNDLDX and BNDSTX instructions in 64-bit mode
</span><span class="doccomment">/// Bit 22: RDPID. RDPID and IA32_TSC_AUX are available if 1.
</span><span class="kw">const </span>RDPID = <span class="number">1 </span>&lt;&lt; <span class="number">22</span>;
<span class="comment">// Bits 29 - 23: Reserved.
</span><span class="doccomment">/// Bit 30: SGX_LC. Supports SGX Launch Configuration if 1.
</span><span class="kw">const </span>SGX_LC = <span class="number">1 </span>&lt;&lt; <span class="number">30</span>;
}
}
<span class="doccomment">/// Direct cache access info (LEAF=0x09).
///
/// # Platforms
/// ❌ AMD (reserved) ✅ Intel
</span><span class="attribute">#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, derive(Serialize, Deserialize))]
</span><span class="kw">pub struct </span>DirectCacheAccessInfo {
eax: u32,
}
<span class="kw">impl </span>DirectCacheAccessInfo {
<span class="doccomment">/// Value of bits \[31:0\] of IA32_PLATFORM_DCA_CAP MSR (address 1F8H)
</span><span class="kw">pub fn </span>get_dca_cap_value(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u32 {
<span class="self">self</span>.eax
}
}
<span class="kw">impl </span>Debug <span class="kw">for </span>DirectCacheAccessInfo {
<span class="kw">fn </span>fmt(<span class="kw-2">&amp;</span><span class="self">self</span>, f: <span class="kw-2">&amp;mut </span>Formatter&lt;<span class="lifetime">&#39;_</span>&gt;) -&gt; core::fmt::Result {
f.debug_struct(<span class="string">&quot;DirectCacheAccessInfo&quot;</span>)
.field(<span class="string">&quot;dca_cap_value&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.get_dca_cap_value())
.finish()
}
}
<span class="doccomment">/// Info about performance monitoring -- how many counters etc. (LEAF=0x0A)
///
/// # Platforms
/// ❌ AMD ✅ Intel
</span><span class="attribute">#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, derive(Serialize, Deserialize))]
</span><span class="kw">pub struct </span>PerformanceMonitoringInfo {
eax: u32,
ebx: PerformanceMonitoringFeaturesEbx,
_ecx: u32,
edx: u32,
}
<span class="kw">impl </span>PerformanceMonitoringInfo {
<span class="doccomment">/// Version ID of architectural performance monitoring. (Bits 07 - 00)
</span><span class="kw">pub fn </span>version_id(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u8 {
get_bits(<span class="self">self</span>.eax, <span class="number">0</span>, <span class="number">7</span>) <span class="kw">as </span>u8
}
<span class="doccomment">/// Number of general-purpose performance monitoring counter per logical processor. (Bits 15- 08)
</span><span class="kw">pub fn </span>number_of_counters(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u8 {
get_bits(<span class="self">self</span>.eax, <span class="number">8</span>, <span class="number">15</span>) <span class="kw">as </span>u8
}
<span class="doccomment">/// Bit width of general-purpose, performance monitoring counter. (Bits 23 - 16)
</span><span class="kw">pub fn </span>counter_bit_width(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u8 {
get_bits(<span class="self">self</span>.eax, <span class="number">16</span>, <span class="number">23</span>) <span class="kw">as </span>u8
}
<span class="doccomment">/// Length of EBX bit vector to enumerate architectural performance monitoring events. (Bits 31 - 24)
</span><span class="kw">pub fn </span>ebx_length(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u8 {
get_bits(<span class="self">self</span>.eax, <span class="number">24</span>, <span class="number">31</span>) <span class="kw">as </span>u8
}
<span class="doccomment">/// Number of fixed-function performance counters (if Version ID &gt; 1). (Bits 04 - 00)
</span><span class="kw">pub fn </span>fixed_function_counters(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u8 {
get_bits(<span class="self">self</span>.edx, <span class="number">0</span>, <span class="number">4</span>) <span class="kw">as </span>u8
}
<span class="doccomment">/// Bit width of fixed-function performance counters (if Version ID &gt; 1). (Bits 12- 05)
</span><span class="kw">pub fn </span>fixed_function_counters_bit_width(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u8 {
get_bits(<span class="self">self</span>.edx, <span class="number">5</span>, <span class="number">12</span>) <span class="kw">as </span>u8
}
<span class="macro">check_bit_fn!</span>(
doc = <span class="string">&quot;AnyThread deprecation&quot;</span>,
has_any_thread_deprecation,
edx,
<span class="number">15
</span>);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;Core cycle event not available if 1.&quot;</span>,
is_core_cyc_ev_unavailable,
ebx,
PerformanceMonitoringFeaturesEbx::CORE_CYC_EV_UNAVAILABLE
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;Instruction retired event not available if 1.&quot;</span>,
is_inst_ret_ev_unavailable,
ebx,
PerformanceMonitoringFeaturesEbx::INST_RET_EV_UNAVAILABLE
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;Reference cycles event not available if 1.&quot;</span>,
is_ref_cycle_ev_unavailable,
ebx,
PerformanceMonitoringFeaturesEbx::REF_CYC_EV_UNAVAILABLE
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;Last-level cache reference event not available if 1.&quot;</span>,
is_cache_ref_ev_unavailable,
ebx,
PerformanceMonitoringFeaturesEbx::CACHE_REF_EV_UNAVAILABLE
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;Last-level cache misses event not available if 1.&quot;</span>,
is_ll_cache_miss_ev_unavailable,
ebx,
PerformanceMonitoringFeaturesEbx::LL_CACHE_MISS_EV_UNAVAILABLE
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;Branch instruction retired event not available if 1.&quot;</span>,
is_branch_inst_ret_ev_unavailable,
ebx,
PerformanceMonitoringFeaturesEbx::BRANCH_INST_RET_EV_UNAVAILABLE
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;Branch mispredict retired event not available if 1.&quot;</span>,
is_branch_midpred_ev_unavailable,
ebx,
PerformanceMonitoringFeaturesEbx::BRANCH_MISPRED_EV_UNAVAILABLE
);
}
<span class="kw">impl </span>Debug <span class="kw">for </span>PerformanceMonitoringInfo {
<span class="kw">fn </span>fmt(<span class="kw-2">&amp;</span><span class="self">self</span>, f: <span class="kw-2">&amp;mut </span>Formatter&lt;<span class="lifetime">&#39;_</span>&gt;) -&gt; core::fmt::Result {
f.debug_struct(<span class="string">&quot;PerformanceMonitoringInfo&quot;</span>)
.field(<span class="string">&quot;version_id&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.version_id())
.field(<span class="string">&quot;number_of_counters&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.number_of_counters())
.field(<span class="string">&quot;counter_bit_width&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.counter_bit_width())
.field(<span class="string">&quot;ebx_length&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.ebx_length())
.field(<span class="string">&quot;fixed_function_counters&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.fixed_function_counters())
.field(
<span class="string">&quot;fixed_function_counters_bit_width&quot;</span>,
<span class="kw-2">&amp;</span><span class="self">self</span>.fixed_function_counters_bit_width(),
)
.finish()
}
}
<span class="macro">bitflags! </span>{
<span class="attribute">#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, derive(Serialize, Deserialize))]
</span><span class="kw">struct </span>PerformanceMonitoringFeaturesEbx: u32 {
<span class="doccomment">/// Core cycle event not available if 1. (Bit 0)
</span><span class="kw">const </span>CORE_CYC_EV_UNAVAILABLE = <span class="number">1 </span>&lt;&lt; <span class="number">0</span>;
<span class="doccomment">/// Instruction retired event not available if 1. (Bit 01)
</span><span class="kw">const </span>INST_RET_EV_UNAVAILABLE = <span class="number">1 </span>&lt;&lt; <span class="number">1</span>;
<span class="doccomment">/// Reference cycles event not available if 1. (Bit 02)
</span><span class="kw">const </span>REF_CYC_EV_UNAVAILABLE = <span class="number">1 </span>&lt;&lt; <span class="number">2</span>;
<span class="doccomment">/// Last-level cache reference event not available if 1. (Bit 03)
</span><span class="kw">const </span>CACHE_REF_EV_UNAVAILABLE = <span class="number">1 </span>&lt;&lt; <span class="number">3</span>;
<span class="doccomment">/// Last-level cache misses event not available if 1. (Bit 04)
</span><span class="kw">const </span>LL_CACHE_MISS_EV_UNAVAILABLE = <span class="number">1 </span>&lt;&lt; <span class="number">4</span>;
<span class="doccomment">/// Branch instruction retired event not available if 1. (Bit 05)
</span><span class="kw">const </span>BRANCH_INST_RET_EV_UNAVAILABLE = <span class="number">1 </span>&lt;&lt; <span class="number">5</span>;
<span class="doccomment">/// Branch mispredict retired event not available if 1. (Bit 06)
</span><span class="kw">const </span>BRANCH_MISPRED_EV_UNAVAILABLE = <span class="number">1 </span>&lt;&lt; <span class="number">6</span>;
}
}
<span class="doccomment">/// Information about topology (LEAF=0x0B).
///
/// Iterates over the system topology in order to retrieve more system
/// information at each level of the topology: how many cores and what kind of
/// cores
///
/// # Platforms
/// ✅ AMD ✅ Intel
</span><span class="attribute">#[derive(Clone)]
#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, derive(Serialize, Deserialize))]
</span><span class="kw">pub struct </span>ExtendedTopologyIter {
<span class="attribute">#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, serde(skip))]
</span>read: CpuIdReader,
level: u32,
is_v2: bool,
}
<span class="doccomment">/// Gives information about the current level in the topology.
///
/// How many cores, what type etc.
</span><span class="attribute">#[derive(PartialEq, Eq)]
#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, derive(Serialize, Deserialize))]
</span><span class="kw">pub struct </span>ExtendedTopologyLevel {
eax: u32,
ebx: u32,
ecx: u32,
edx: u32,
}
<span class="kw">impl </span>fmt::Debug <span class="kw">for </span>ExtendedTopologyLevel {
<span class="kw">fn </span>fmt(<span class="kw-2">&amp;</span><span class="self">self</span>, f: <span class="kw-2">&amp;mut </span>fmt::Formatter) -&gt; fmt::Result {
f.debug_struct(<span class="string">&quot;ExtendedTopologyLevel&quot;</span>)
.field(<span class="string">&quot;processors&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.processors())
.field(<span class="string">&quot;number&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.level_number())
.field(<span class="string">&quot;type&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.level_type())
.field(<span class="string">&quot;x2apic_id&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.x2apic_id())
.field(<span class="string">&quot;next_apic_id&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.shift_right_for_next_apic_id())
.finish()
}
}
<span class="kw">impl </span>ExtendedTopologyLevel {
<span class="doccomment">/// Number of logical processors at this level type.
/// The number reflects configuration as shipped.
</span><span class="kw">pub fn </span>processors(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u16 {
get_bits(<span class="self">self</span>.ebx, <span class="number">0</span>, <span class="number">15</span>) <span class="kw">as </span>u16
}
<span class="doccomment">/// Level number.
</span><span class="kw">pub fn </span>level_number(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u8 {
get_bits(<span class="self">self</span>.ecx, <span class="number">0</span>, <span class="number">7</span>) <span class="kw">as </span>u8
}
<span class="comment">// Level type.
</span><span class="kw">pub fn </span>level_type(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; TopologyType {
<span class="kw">match </span>get_bits(<span class="self">self</span>.ecx, <span class="number">8</span>, <span class="number">15</span>) {
<span class="number">0 </span>=&gt; TopologyType::Invalid,
<span class="number">1 </span>=&gt; TopologyType::SMT,
<span class="number">2 </span>=&gt; TopologyType::Core,
<span class="number">3 </span>=&gt; TopologyType::Module,
<span class="number">4 </span>=&gt; TopologyType::Tile,
<span class="number">5 </span>=&gt; TopologyType::Die,
<span class="kw">_ </span>=&gt; <span class="macro">unreachable!</span>(),
}
}
<span class="doccomment">/// x2APIC ID the current logical processor. (Bits 31-00)
</span><span class="kw">pub fn </span>x2apic_id(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u32 {
<span class="self">self</span>.edx
}
<span class="doccomment">/// Number of bits to shift right on x2APIC ID to get a unique topology ID of the next level type. (Bits 04-00)
/// All logical processors with the same next level ID share current level.
</span><span class="kw">pub fn </span>shift_right_for_next_apic_id(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u32 {
get_bits(<span class="self">self</span>.eax, <span class="number">0</span>, <span class="number">4</span>)
}
}
<span class="doccomment">/// What type of core we have at this level in the topology (real CPU or hyper-threaded).
</span><span class="attribute">#[derive(PartialEq, Eq, Debug)]
#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, derive(Serialize, Deserialize))]
</span><span class="kw">pub enum </span>TopologyType {
Invalid = <span class="number">0</span>,
<span class="doccomment">/// Hyper-thread (Simultaneous multithreading)
</span>SMT = <span class="number">1</span>,
Core = <span class="number">2</span>,
Module = <span class="number">3</span>,
Tile = <span class="number">4</span>,
Die = <span class="number">5</span>,
}
<span class="kw">impl </span>fmt::Display <span class="kw">for </span>TopologyType {
<span class="kw">fn </span>fmt(<span class="kw-2">&amp;</span><span class="self">self</span>, f: <span class="kw-2">&amp;mut </span>fmt::Formatter) -&gt; fmt::Result {
<span class="kw">let </span>data = <span class="kw">match </span><span class="self">self </span>{
TopologyType::Invalid =&gt; <span class="string">&quot;Invalid&quot;</span>,
TopologyType::SMT =&gt; <span class="string">&quot;SMT&quot;</span>,
TopologyType::Core =&gt; <span class="string">&quot;Core&quot;</span>,
TopologyType::Module =&gt; <span class="string">&quot;Module&quot;</span>,
TopologyType::Tile =&gt; <span class="string">&quot;Tile&quot;</span>,
TopologyType::Die =&gt; <span class="string">&quot;Die&quot;</span>,
};
f.write_str(data)
}
}
<span class="kw">impl </span>Iterator <span class="kw">for </span>ExtendedTopologyIter {
<span class="kw">type </span>Item = ExtendedTopologyLevel;
<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;ExtendedTopologyLevel&gt; {
<span class="kw">let </span>res = <span class="kw">if </span><span class="self">self</span>.is_v2 {
<span class="self">self</span>.read.cpuid2(EAX_EXTENDED_TOPOLOGY_INFO_V2, <span class="self">self</span>.level)
} <span class="kw">else </span>{
<span class="self">self</span>.read.cpuid2(EAX_EXTENDED_TOPOLOGY_INFO, <span class="self">self</span>.level)
};
<span class="self">self</span>.level += <span class="number">1</span>;
<span class="kw">let </span>et = ExtendedTopologyLevel {
eax: res.eax,
ebx: res.ebx,
ecx: res.ecx,
edx: res.edx,
};
<span class="kw">match </span>et.level_type() {
TopologyType::Invalid =&gt; <span class="prelude-val">None</span>,
<span class="kw">_ </span>=&gt; <span class="prelude-val">Some</span>(et),
}
}
}
<span class="kw">impl </span>Debug <span class="kw">for </span>ExtendedTopologyIter {
<span class="kw">fn </span>fmt(<span class="kw-2">&amp;</span><span class="self">self</span>, f: <span class="kw-2">&amp;mut </span>Formatter&lt;<span class="lifetime">&#39;_</span>&gt;) -&gt; core::fmt::Result {
<span class="kw">let </span><span class="kw-2">mut </span>debug = f.debug_list();
<span class="self">self</span>.clone().for_each(|<span class="kw-2">ref </span>item| {
debug.entry(item);
});
debug.finish()
}
}
<span class="macro">bitflags! </span>{
<span class="attribute">#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, derive(Serialize, Deserialize))]
</span><span class="kw">struct </span>ExtendedStateInfoXCR0Flags: u32 {
<span class="doccomment">/// legacy x87 (Bit 00).
</span><span class="kw">const </span>LEGACY_X87 = <span class="number">1 </span>&lt;&lt; <span class="number">0</span>;
<span class="doccomment">/// 128-bit SSE (Bit 01).
</span><span class="kw">const </span>SSE128 = <span class="number">1 </span>&lt;&lt; <span class="number">1</span>;
<span class="doccomment">/// 256-bit AVX (Bit 02).
</span><span class="kw">const </span>AVX256 = <span class="number">1 </span>&lt;&lt; <span class="number">2</span>;
<span class="doccomment">/// MPX BNDREGS (Bit 03).
</span><span class="kw">const </span>MPX_BNDREGS = <span class="number">1 </span>&lt;&lt; <span class="number">3</span>;
<span class="doccomment">/// MPX BNDCSR (Bit 04).
</span><span class="kw">const </span>MPX_BNDCSR = <span class="number">1 </span>&lt;&lt; <span class="number">4</span>;
<span class="doccomment">/// AVX512 OPMASK (Bit 05).
</span><span class="kw">const </span>AVX512_OPMASK = <span class="number">1 </span>&lt;&lt; <span class="number">5</span>;
<span class="doccomment">/// AVX ZMM Hi256 (Bit 06).
</span><span class="kw">const </span>AVX512_ZMM_HI256 = <span class="number">1 </span>&lt;&lt; <span class="number">6</span>;
<span class="doccomment">/// AVX 512 ZMM Hi16 (Bit 07).
</span><span class="kw">const </span>AVX512_ZMM_HI16 = <span class="number">1 </span>&lt;&lt; <span class="number">7</span>;
<span class="doccomment">/// PKRU state (Bit 09).
</span><span class="kw">const </span>PKRU = <span class="number">1 </span>&lt;&lt; <span class="number">9</span>;
<span class="doccomment">/// IA32_XSS HDC State (Bit 13).
</span><span class="kw">const </span>IA32_XSS_HDC = <span class="number">1 </span>&lt;&lt; <span class="number">13</span>;
}
}
<span class="macro">bitflags! </span>{
<span class="attribute">#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, derive(Serialize, Deserialize))]
</span><span class="kw">struct </span>ExtendedStateInfoXSSFlags: u32 {
<span class="doccomment">/// IA32_XSS PT (Trace Packet) State (Bit 08).
</span><span class="kw">const </span>PT = <span class="number">1 </span>&lt;&lt; <span class="number">8</span>;
<span class="doccomment">/// IA32_XSS HDC State (Bit 13).
</span><span class="kw">const </span>HDC = <span class="number">1 </span>&lt;&lt; <span class="number">13</span>;
}
}
<span class="doccomment">/// Information for saving/restoring extended register state (LEAF=0x0D).
///
/// # Platforms
/// ✅ AMD ✅ Intel
</span><span class="attribute">#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, derive(Serialize, Deserialize))]
</span><span class="kw">pub struct </span>ExtendedStateInfo {
<span class="attribute">#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, serde(skip))]
</span>read: CpuIdReader,
eax: ExtendedStateInfoXCR0Flags,
ebx: u32,
ecx: u32,
_edx: u32,
eax1: u32,
ebx1: u32,
ecx1: ExtendedStateInfoXSSFlags,
_edx1: u32,
}
<span class="kw">impl </span>ExtendedStateInfo {
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;Support for legacy x87 in XCR0.&quot;</span>,
xcr0_supports_legacy_x87,
eax,
ExtendedStateInfoXCR0Flags::LEGACY_X87
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;Support for SSE 128-bit in XCR0.&quot;</span>,
xcr0_supports_sse_128,
eax,
ExtendedStateInfoXCR0Flags::SSE128
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;Support for AVX 256-bit in XCR0.&quot;</span>,
xcr0_supports_avx_256,
eax,
ExtendedStateInfoXCR0Flags::AVX256
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;Support for MPX BNDREGS in XCR0.&quot;</span>,
xcr0_supports_mpx_bndregs,
eax,
ExtendedStateInfoXCR0Flags::MPX_BNDREGS
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;Support for MPX BNDCSR in XCR0.&quot;</span>,
xcr0_supports_mpx_bndcsr,
eax,
ExtendedStateInfoXCR0Flags::MPX_BNDCSR
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;Support for AVX512 OPMASK in XCR0.&quot;</span>,
xcr0_supports_avx512_opmask,
eax,
ExtendedStateInfoXCR0Flags::AVX512_OPMASK
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;Support for AVX512 ZMM Hi256 XCR0.&quot;</span>,
xcr0_supports_avx512_zmm_hi256,
eax,
ExtendedStateInfoXCR0Flags::AVX512_ZMM_HI256
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;Support for AVX512 ZMM Hi16 in XCR0.&quot;</span>,
xcr0_supports_avx512_zmm_hi16,
eax,
ExtendedStateInfoXCR0Flags::AVX512_ZMM_HI16
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;Support for PKRU in XCR0.&quot;</span>,
xcr0_supports_pkru,
eax,
ExtendedStateInfoXCR0Flags::PKRU
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;Support for PT in IA32_XSS.&quot;</span>,
ia32_xss_supports_pt,
ecx1,
ExtendedStateInfoXSSFlags::PT
);
<span class="macro">check_flag!</span>(
doc = <span class="string">&quot;Support for HDC in IA32_XSS.&quot;</span>,
ia32_xss_supports_hdc,
ecx1,
ExtendedStateInfoXSSFlags::HDC
);
<span class="doccomment">/// Maximum size (bytes, from the beginning of the XSAVE/XRSTOR save area) required by
/// enabled features in XCR0. May be different than ECX if some features at the end of the XSAVE save area
/// are not enabled.
</span><span class="kw">pub fn </span>xsave_area_size_enabled_features(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u32 {
<span class="self">self</span>.ebx
}
<span class="doccomment">/// Maximum size (bytes, from the beginning of the XSAVE/XRSTOR save area) of the
/// XSAVE/XRSTOR save area required by all supported features in the processor,
/// i.e all the valid bit fields in XCR0.
</span><span class="kw">pub fn </span>xsave_area_size_supported_features(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u32 {
<span class="self">self</span>.ecx
}
<span class="doccomment">/// CPU has xsaveopt feature.
</span><span class="kw">pub fn </span>has_xsaveopt(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.eax1 &amp; <span class="number">0x1 </span>&gt; <span class="number">0
</span>}
<span class="doccomment">/// Supports XSAVEC and the compacted form of XRSTOR if set.
</span><span class="kw">pub fn </span>has_xsavec(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.eax1 &amp; <span class="number">0b10 </span>&gt; <span class="number">0
</span>}
<span class="doccomment">/// Supports XGETBV with ECX = 1 if set.
</span><span class="kw">pub fn </span>has_xgetbv(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.eax1 &amp; <span class="number">0b100 </span>&gt; <span class="number">0
</span>}
<span class="doccomment">/// Supports XSAVES/XRSTORS and IA32_XSS if set.
</span><span class="kw">pub fn </span>has_xsaves_xrstors(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.eax1 &amp; <span class="number">0b1000 </span>&gt; <span class="number">0
</span>}
<span class="doccomment">/// The size in bytes of the XSAVE area containing all states enabled by XCRO | IA32_XSS.
</span><span class="kw">pub fn </span>xsave_size(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u32 {
<span class="self">self</span>.ebx1
}
<span class="doccomment">/// Iterator over extended state enumeration levels &gt;= 2.
</span><span class="kw">pub fn </span>iter(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; ExtendedStateIter {
ExtendedStateIter {
read: <span class="self">self</span>.read,
level: <span class="number">1</span>,
supported_xcr0: <span class="self">self</span>.eax.bits(),
supported_xss: <span class="self">self</span>.ecx1.bits(),
}
}
}
<span class="kw">impl </span>Debug <span class="kw">for </span>ExtendedStateInfo {
<span class="kw">fn </span>fmt(<span class="kw-2">&amp;</span><span class="self">self</span>, f: <span class="kw-2">&amp;mut </span>Formatter&lt;<span class="lifetime">&#39;_</span>&gt;) -&gt; core::fmt::Result {
f.debug_struct(<span class="string">&quot;ExtendedStateInfo&quot;</span>)
.field(<span class="string">&quot;eax&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.eax)
.field(<span class="string">&quot;ecx1&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.ecx1)
.field(
<span class="string">&quot;xsave_area_size_enabled_features&quot;</span>,
<span class="kw-2">&amp;</span><span class="self">self</span>.xsave_area_size_enabled_features(),
)
.field(
<span class="string">&quot;xsave_area_size_supported_features&quot;</span>,
<span class="kw-2">&amp;</span><span class="self">self</span>.xsave_area_size_supported_features(),
)
.field(<span class="string">&quot;has_xsaveopt&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.has_xsaveopt())
.field(<span class="string">&quot;has_xsavec&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.has_xsavec())
.field(<span class="string">&quot;has_xgetbv&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.has_xgetbv())
.field(<span class="string">&quot;has_xsaves_xrstors&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.has_xsaves_xrstors())
.field(<span class="string">&quot;xsave_size&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.xsave_size())
.field(<span class="string">&quot;extended_state_iter&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.iter())
.finish()
}
}
<span class="doccomment">/// Yields [ExtendedState] structs.
</span><span class="attribute">#[derive(Clone)]
#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, derive(Serialize, Deserialize))]
</span><span class="kw">pub struct </span>ExtendedStateIter {
<span class="attribute">#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, serde(skip))]
</span>read: CpuIdReader,
level: u32,
supported_xcr0: u32,
supported_xss: u32,
}
<span class="doccomment">/// When CPUID executes with EAX set to 0DH and ECX = n (n &gt; 1, and is a valid
/// sub-leaf index), the processor returns information about the size and offset
/// of each processor extended state save area within the XSAVE/XRSTOR area.
///
/// The iterator goes over the valid sub-leaves and obtain size and offset
/// information for each processor extended state save area:
</span><span class="kw">impl </span>Iterator <span class="kw">for </span>ExtendedStateIter {
<span class="kw">type </span>Item = ExtendedState;
<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;ExtendedState&gt; {
<span class="self">self</span>.level += <span class="number">1</span>;
<span class="kw">if </span><span class="self">self</span>.level &gt; <span class="number">31 </span>{
<span class="kw">return </span><span class="prelude-val">None</span>;
}
<span class="kw">let </span>bit = <span class="number">1 </span>&lt;&lt; <span class="self">self</span>.level;
<span class="kw">if </span>(<span class="self">self</span>.supported_xcr0 &amp; bit &gt; <span class="number">0</span>) || (<span class="self">self</span>.supported_xss &amp; bit &gt; <span class="number">0</span>) {
<span class="kw">let </span>res = <span class="self">self</span>.read.cpuid2(EAX_EXTENDED_STATE_INFO, <span class="self">self</span>.level);
<span class="kw">return </span><span class="prelude-val">Some</span>(ExtendedState {
subleaf: <span class="self">self</span>.level,
eax: res.eax,
ebx: res.ebx,
ecx: res.ecx,
});
}
<span class="self">self</span>.next()
}
}
<span class="kw">impl </span>Debug <span class="kw">for </span>ExtendedStateIter {
<span class="kw">fn </span>fmt(<span class="kw-2">&amp;</span><span class="self">self</span>, f: <span class="kw-2">&amp;mut </span>Formatter&lt;<span class="lifetime">&#39;_</span>&gt;) -&gt; fmt::Result {
<span class="kw">let </span><span class="kw-2">mut </span>debug = f.debug_list();
<span class="self">self</span>.clone().for_each(|<span class="kw-2">ref </span>item| {
debug.entry(item);
});
debug.finish()
}
}
<span class="doccomment">/// What kidn of extended register state this is.
</span><span class="attribute">#[derive(PartialEq, Eq, Debug)]
#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, derive(Serialize, Deserialize))]
#[repr(u32)]
</span><span class="kw">pub enum </span>ExtendedRegisterType {
Avx,
MpxBndregs,
MpxBndcsr,
Avx512Opmask,
Avx512ZmmHi256,
Avx512ZmmHi16,
Pt,
Pkru,
Hdc,
Unknown(u32),
}
<span class="kw">impl </span>From&lt;u32&gt; <span class="kw">for </span>ExtendedRegisterType {
<span class="kw">fn </span>from(value: u32) -&gt; ExtendedRegisterType {
<span class="kw">match </span>value {
<span class="number">0x2 </span>=&gt; ExtendedRegisterType::Avx,
<span class="number">0x3 </span>=&gt; ExtendedRegisterType::MpxBndregs,
<span class="number">0x4 </span>=&gt; ExtendedRegisterType::MpxBndcsr,
<span class="number">0x5 </span>=&gt; ExtendedRegisterType::Avx512Opmask,
<span class="number">0x6 </span>=&gt; ExtendedRegisterType::Avx512ZmmHi256,
<span class="number">0x7 </span>=&gt; ExtendedRegisterType::Avx512ZmmHi16,
<span class="number">0x8 </span>=&gt; ExtendedRegisterType::Pt,
<span class="number">0x9 </span>=&gt; ExtendedRegisterType::Pkru,
<span class="number">0xd </span>=&gt; ExtendedRegisterType::Hdc,
x =&gt; ExtendedRegisterType::Unknown(x),
}
}
}
<span class="kw">impl </span>fmt::Display <span class="kw">for </span>ExtendedRegisterType {
<span class="kw">fn </span>fmt(<span class="kw-2">&amp;</span><span class="self">self</span>, f: <span class="kw-2">&amp;mut </span>fmt::Formatter) -&gt; fmt::Result {
<span class="kw">let </span>data = <span class="kw">match </span><span class="self">self </span>{
ExtendedRegisterType::Avx =&gt; <span class="string">&quot;AVX/YMM&quot;</span>,
ExtendedRegisterType::MpxBndregs =&gt; <span class="string">&quot;MPX BNDREGS&quot;</span>,
ExtendedRegisterType::MpxBndcsr =&gt; <span class="string">&quot;MPX BNDCSR&quot;</span>,
ExtendedRegisterType::Avx512Opmask =&gt; <span class="string">&quot;AVX-512 opmask&quot;</span>,
ExtendedRegisterType::Avx512ZmmHi256 =&gt; <span class="string">&quot;AVX-512 ZMM_Hi256&quot;</span>,
ExtendedRegisterType::Avx512ZmmHi16 =&gt; <span class="string">&quot;AVX-512 Hi16_ZMM&quot;</span>,
ExtendedRegisterType::Pkru =&gt; <span class="string">&quot;PKRU&quot;</span>,
ExtendedRegisterType::Pt =&gt; <span class="string">&quot;PT&quot;</span>,
ExtendedRegisterType::Hdc =&gt; <span class="string">&quot;HDC&quot;</span>,
ExtendedRegisterType::Unknown(t) =&gt; {
<span class="kw">return </span><span class="macro">write!</span>(f, <span class="string">&quot;Unknown({})&quot;</span>, t);
}
};
f.write_str(data)
}
}
<span class="doccomment">/// Where the extended register state is stored.
</span><span class="attribute">#[derive(PartialEq, Eq, Debug)]
#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, derive(Serialize, Deserialize))]
</span><span class="kw">pub enum </span>ExtendedRegisterStateLocation {
Xcr0,
Ia32Xss,
}
<span class="kw">impl </span>fmt::Display <span class="kw">for </span>ExtendedRegisterStateLocation {
<span class="kw">fn </span>fmt(<span class="kw-2">&amp;</span><span class="self">self</span>, f: <span class="kw-2">&amp;mut </span>fmt::Formatter) -&gt; fmt::Result {
<span class="kw">let </span>data = <span class="kw">match </span><span class="self">self </span>{
ExtendedRegisterStateLocation::Xcr0 =&gt; <span class="string">&quot;XCR0 (user state)&quot;</span>,
ExtendedRegisterStateLocation::Ia32Xss =&gt; <span class="string">&quot;IA32_XSS (supervisor state)&quot;</span>,
};
f.write_str(data)
}
}
<span class="doccomment">/// ExtendedState subleaf structure for things that need to be restored.
</span><span class="attribute">#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, derive(Serialize, Deserialize))]
</span><span class="kw">pub struct </span>ExtendedState {
<span class="kw">pub </span>subleaf: u32,
eax: u32,
ebx: u32,
ecx: u32,
}
<span class="kw">impl </span>ExtendedState {
<span class="doccomment">/// Returns which register this specific extended subleaf contains information for.
</span><span class="kw">pub fn </span>register(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; ExtendedRegisterType {
<span class="self">self</span>.subleaf.into()
}
<span class="doccomment">/// The size in bytes (from the offset specified in EBX) of the save area
/// for an extended state feature associated with a valid sub-leaf index, n.
/// This field reports 0 if the sub-leaf index, n, is invalid.
</span><span class="kw">pub fn </span>size(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u32 {
<span class="self">self</span>.eax
}
<span class="doccomment">/// The offset in bytes of this extended state components save area
/// from the beginning of the XSAVE/XRSTOR area.
</span><span class="kw">pub fn </span>offset(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u32 {
<span class="self">self</span>.ebx
}
<span class="kw">pub fn </span>location(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; ExtendedRegisterStateLocation {
<span class="kw">if </span><span class="self">self</span>.is_in_xcr0() {
ExtendedRegisterStateLocation::Xcr0
} <span class="kw">else </span>{
ExtendedRegisterStateLocation::Ia32Xss
}
}
<span class="doccomment">/// True if the bit n (corresponding to the sub-leaf index)
/// is supported in the IA32_XSS MSR;
///
/// # Deprecation note
/// This will likely be removed in the future. Use `location()` instead.
</span><span class="kw">pub fn </span>is_in_ia32_xss(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.ecx &amp; <span class="number">0b1 </span>&gt; <span class="number">0
</span>}
<span class="doccomment">/// True if bit n is supported in XCR0.
///
/// # Deprecation note
/// This will likely be removed in the future. Use `location()` instead.
</span><span class="kw">pub fn </span>is_in_xcr0(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.ecx &amp; <span class="number">0b1 </span>== <span class="number">0
</span>}
<span class="doccomment">/// Returns true when the compacted format of an XSAVE area is used,
/// this extended state component located on the next 64-byte
/// boundary following the preceding state component
/// (otherwise, it is located immediately following the preceding state component).
</span><span class="kw">pub fn </span>is_compacted_format(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<span class="self">self</span>.ecx &amp; <span class="number">0b10 </span>&gt; <span class="number">0
</span>}
}
<span class="kw">impl </span>Debug <span class="kw">for </span>ExtendedState {
<span class="kw">fn </span>fmt(<span class="kw-2">&amp;</span><span class="self">self</span>, f: <span class="kw-2">&amp;mut </span>Formatter&lt;<span class="lifetime">&#39;_</span>&gt;) -&gt; fmt::Result {
f.debug_struct(<span class="string">&quot;ExtendedState&quot;</span>)
.field(<span class="string">&quot;size&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.size())
.field(<span class="string">&quot;offset&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.offset())
.field(<span class="string">&quot;is_in_ia32_xss&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.is_in_ia32_xss())
.field(<span class="string">&quot;is_in_xcr0&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.is_in_xcr0())
.field(<span class="string">&quot;is_compacted_format&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.is_compacted_format())
.finish()
}
}
<span class="doccomment">/// Intel Resource Director Technology RDT (LEAF=0x0F).
///
/// Monitoring Enumeration Sub-leaf (EAX = 0FH, ECX = 0 and ECX = 1)
/// # Platforms
/// ❌ AMD ✅ Intel
</span><span class="attribute">#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, derive(Serialize, Deserialize))]
</span><span class="kw">pub struct </span>RdtMonitoringInfo {
<span class="attribute">#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, serde(skip))]
</span>read: CpuIdReader,
ebx: u32,
edx: u32,
}
<span class="kw">impl </span>RdtMonitoringInfo {
<span class="doccomment">/// Maximum range (zero-based) of RMID within this physical processor of all types.
</span><span class="kw">pub fn </span>rmid_range(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u32 {
<span class="self">self</span>.ebx
}
<span class="macro">check_bit_fn!</span>(
doc = <span class="string">&quot;Supports L3 Cache Intel RDT Monitoring.&quot;</span>,
has_l3_monitoring,
edx,
<span class="number">1
</span>);
<span class="doccomment">/// L3 Cache Monitoring.
</span><span class="kw">pub fn </span>l3_monitoring(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;L3MonitoringInfo&gt; {
<span class="kw">if </span><span class="self">self</span>.has_l3_monitoring() {
<span class="kw">let </span>res = <span class="self">self</span>.read.cpuid2(EAX_RDT_MONITORING, <span class="number">1</span>);
<span class="prelude-val">Some</span>(L3MonitoringInfo {
ebx: res.ebx,
ecx: res.ecx,
edx: res.edx,
})
} <span class="kw">else </span>{
<span class="prelude-val">None
</span>}
}
}
<span class="kw">impl </span>Debug <span class="kw">for </span>RdtMonitoringInfo {
<span class="kw">fn </span>fmt(<span class="kw-2">&amp;</span><span class="self">self</span>, f: <span class="kw-2">&amp;mut </span>Formatter&lt;<span class="lifetime">&#39;_</span>&gt;) -&gt; core::fmt::Result {
f.debug_struct(<span class="string">&quot;RdtMonitoringInfo&quot;</span>)
.field(<span class="string">&quot;rmid_range&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.rmid_range())
.field(<span class="string">&quot;l3_monitoring&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.l3_monitoring())
.finish()
}
}
<span class="doccomment">/// Information about L3 cache monitoring.
</span><span class="attribute">#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, derive(Serialize, Deserialize))]
</span><span class="kw">pub struct </span>L3MonitoringInfo {
ebx: u32,
ecx: u32,
edx: u32,
}
<span class="kw">impl </span>L3MonitoringInfo {
<span class="doccomment">/// Conversion factor from reported IA32_QM_CTR value to occupancy metric (bytes).
</span><span class="kw">pub fn </span>conversion_factor(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u32 {
<span class="self">self</span>.ebx
}
<span class="doccomment">/// Maximum range (zero-based) of RMID of L3.
</span><span class="kw">pub fn </span>maximum_rmid_range(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u32 {
<span class="self">self</span>.ecx
}
<span class="macro">check_bit_fn!</span>(
doc = <span class="string">&quot;Supports occupancy monitoring.&quot;</span>,
has_occupancy_monitoring,
edx,
<span class="number">0
</span>);
<span class="macro">check_bit_fn!</span>(
doc = <span class="string">&quot;Supports total bandwidth monitoring.&quot;</span>,
has_total_bandwidth_monitoring,
edx,
<span class="number">1
</span>);
<span class="macro">check_bit_fn!</span>(
doc = <span class="string">&quot;Supports local bandwidth monitoring.&quot;</span>,
has_local_bandwidth_monitoring,
edx,
<span class="number">2
</span>);
}
<span class="kw">impl </span>Debug <span class="kw">for </span>L3MonitoringInfo {
<span class="kw">fn </span>fmt(<span class="kw-2">&amp;</span><span class="self">self</span>, f: <span class="kw-2">&amp;mut </span>Formatter&lt;<span class="lifetime">&#39;_</span>&gt;) -&gt; core::fmt::Result {
f.debug_struct(<span class="string">&quot;L3MonitoringInfo&quot;</span>)
.field(<span class="string">&quot;conversion_factor&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.conversion_factor())
.field(<span class="string">&quot;maximum_rmid_range&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.maximum_rmid_range())
.finish()
}
}
<span class="doccomment">/// Quality of service enforcement information (LEAF=0x10).
///
/// # Platforms
/// ❌ AMD ✅ Intel
</span><span class="attribute">#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, derive(Serialize, Deserialize))]
</span><span class="kw">pub struct </span>RdtAllocationInfo {
<span class="attribute">#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, serde(skip))]
</span>read: CpuIdReader,
ebx: u32,
}
<span class="kw">impl </span>RdtAllocationInfo {
<span class="macro">check_bit_fn!</span>(doc = <span class="string">&quot;Supports L3 Cache Allocation.&quot;</span>, has_l3_cat, ebx, <span class="number">1</span>);
<span class="macro">check_bit_fn!</span>(doc = <span class="string">&quot;Supports L2 Cache Allocation.&quot;</span>, has_l2_cat, ebx, <span class="number">2</span>);
<span class="macro">check_bit_fn!</span>(
doc = <span class="string">&quot;Supports Memory Bandwidth Allocation.&quot;</span>,
has_memory_bandwidth_allocation,
ebx,
<span class="number">3
</span>);
<span class="doccomment">/// L3 Cache Allocation Information.
</span><span class="kw">pub fn </span>l3_cat(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;L3CatInfo&gt; {
<span class="kw">if </span><span class="self">self</span>.has_l3_cat() {
<span class="kw">let </span>res = <span class="self">self</span>.read.cpuid2(EAX_RDT_ALLOCATION, <span class="number">1</span>);
<span class="prelude-val">Some</span>(L3CatInfo {
eax: res.eax,
ebx: res.ebx,
ecx: res.ecx,
edx: res.edx,
})
} <span class="kw">else </span>{
<span class="prelude-val">None
</span>}
}
<span class="doccomment">/// L2 Cache Allocation Information.
</span><span class="kw">pub fn </span>l2_cat(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;L2CatInfo&gt; {
<span class="kw">if </span><span class="self">self</span>.has_l2_cat() {
<span class="kw">let </span>res = <span class="self">self</span>.read.cpuid2(EAX_RDT_ALLOCATION, <span class="number">2</span>);
<span class="prelude-val">Some</span>(L2CatInfo {
eax: res.eax,
ebx: res.ebx,
edx: res.edx,
})
} <span class="kw">else </span>{
<span class="prelude-val">None
</span>}
}
<span class="doccomment">/// Memory Bandwidth Allocation Information.
</span><span class="kw">pub fn </span>memory_bandwidth_allocation(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;MemBwAllocationInfo&gt; {
<span class="kw">if </span><span class="self">self</span>.has_memory_bandwidth_allocation() {
<span class="kw">let </span>res = <span class="self">self</span>.read.cpuid2(EAX_RDT_ALLOCATION, <span class="number">3</span>);
<span class="prelude-val">Some</span>(MemBwAllocationInfo {
eax: res.eax,
ecx: res.ecx,
edx: res.edx,
})
} <span class="kw">else </span>{
<span class="prelude-val">None
</span>}
}
}
<span class="kw">impl </span>Debug <span class="kw">for </span>RdtAllocationInfo {
<span class="kw">fn </span>fmt(<span class="kw-2">&amp;</span><span class="self">self</span>, f: <span class="kw-2">&amp;mut </span>Formatter&lt;<span class="lifetime">&#39;_</span>&gt;) -&gt; core::fmt::Result {
f.debug_struct(<span class="string">&quot;RdtAllocationInfo&quot;</span>)
.field(<span class="string">&quot;l3_cat&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.l3_cat())
.field(<span class="string">&quot;l2_cat&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.l2_cat())
.field(
<span class="string">&quot;memory_bandwidth_allocation&quot;</span>,
<span class="kw-2">&amp;</span><span class="self">self</span>.memory_bandwidth_allocation(),
)
.finish()
}
}
<span class="doccomment">/// L3 Cache Allocation Technology Enumeration Sub-leaf (LEAF=0x10, SUBLEAF=1).
</span><span class="attribute">#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, derive(Serialize, Deserialize))]
</span><span class="kw">pub struct </span>L3CatInfo {
eax: u32,
ebx: u32,
ecx: u32,
edx: u32,
}
<span class="kw">impl </span>L3CatInfo {
<span class="doccomment">/// Length of the capacity bit mask.
</span><span class="kw">pub fn </span>capacity_mask_length(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u8 {
(get_bits(<span class="self">self</span>.eax, <span class="number">0</span>, <span class="number">4</span>) + <span class="number">1</span>) <span class="kw">as </span>u8
}
<span class="doccomment">/// Bit-granular map of isolation/contention of allocation units.
</span><span class="kw">pub fn </span>isolation_bitmap(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u32 {
<span class="self">self</span>.ebx
}
<span class="doccomment">/// Highest COS number supported for this Leaf.
</span><span class="kw">pub fn </span>highest_cos(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u16 {
get_bits(<span class="self">self</span>.edx, <span class="number">0</span>, <span class="number">15</span>) <span class="kw">as </span>u16
}
<span class="macro">check_bit_fn!</span>(
doc = <span class="string">&quot;Is Code and Data Prioritization Technology supported?&quot;</span>,
has_code_data_prioritization,
ecx,
<span class="number">2
</span>);
}
<span class="kw">impl </span>Debug <span class="kw">for </span>L3CatInfo {
<span class="kw">fn </span>fmt(<span class="kw-2">&amp;</span><span class="self">self</span>, f: <span class="kw-2">&amp;mut </span>Formatter&lt;<span class="lifetime">&#39;_</span>&gt;) -&gt; core::fmt::Result {
f.debug_struct(<span class="string">&quot;L3CatInfo&quot;</span>)
.field(<span class="string">&quot;capacity_mask_length&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.capacity_mask_length())
.field(<span class="string">&quot;isolation_bitmap&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.isolation_bitmap())
.field(<span class="string">&quot;highest_cos&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.highest_cos())
.finish()
}
}
<span class="doccomment">/// L2 Cache Allocation Technology Enumeration Sub-leaf (LEAF=0x10, SUBLEAF=2).
</span><span class="attribute">#[derive(Eq, PartialEq)]
#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, derive(Serialize, Deserialize))]
</span><span class="kw">pub struct </span>L2CatInfo {
eax: u32,
ebx: u32,
edx: u32,
}
<span class="kw">impl </span>L2CatInfo {
<span class="doccomment">/// Length of the capacity bit mask.
</span><span class="kw">pub fn </span>capacity_mask_length(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u8 {
(get_bits(<span class="self">self</span>.eax, <span class="number">0</span>, <span class="number">4</span>) + <span class="number">1</span>) <span class="kw">as </span>u8
}
<span class="doccomment">/// Bit-granular map of isolation/contention of allocation units.
</span><span class="kw">pub fn </span>isolation_bitmap(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u32 {
<span class="self">self</span>.ebx
}
<span class="doccomment">/// Highest COS number supported for this Leaf.
</span><span class="kw">pub fn </span>highest_cos(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u16 {
get_bits(<span class="self">self</span>.edx, <span class="number">0</span>, <span class="number">15</span>) <span class="kw">as </span>u16
}
}
<span class="kw">impl </span>Debug <span class="kw">for </span>L2CatInfo {
<span class="kw">fn </span>fmt(<span class="kw-2">&amp;</span><span class="self">self</span>, f: <span class="kw-2">&amp;mut </span>Formatter&lt;<span class="lifetime">&#39;_</span>&gt;) -&gt; core::fmt::Result {
f.debug_struct(<span class="string">&quot;L2CatInfo&quot;</span>)
.field(<span class="string">&quot;capacity_mask_length&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.capacity_mask_length())
.field(<span class="string">&quot;isolation_bitmap&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.isolation_bitmap())
.field(<span class="string">&quot;highest_cos&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.highest_cos())
.finish()
}
}
<span class="doccomment">/// Memory Bandwidth Allocation Enumeration Sub-leaf (LEAF=0x10, SUBLEAF=3).
</span><span class="attribute">#[derive(Eq, PartialEq)]
#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, derive(Serialize, Deserialize))]
</span><span class="kw">pub struct </span>MemBwAllocationInfo {
eax: u32,
ecx: u32,
edx: u32,
}
<span class="kw">impl </span>MemBwAllocationInfo {
<span class="doccomment">/// Reports the maximum MBA throttling value supported for the corresponding ResID.
</span><span class="kw">pub fn </span>max_hba_throttling(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u16 {
(get_bits(<span class="self">self</span>.eax, <span class="number">0</span>, <span class="number">11</span>) + <span class="number">1</span>) <span class="kw">as </span>u16
}
<span class="doccomment">/// Highest COS number supported for this Leaf.
</span><span class="kw">pub fn </span>highest_cos(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u16 {
get_bits(<span class="self">self</span>.edx, <span class="number">0</span>, <span class="number">15</span>) <span class="kw">as </span>u16
}
<span class="macro">check_bit_fn!</span>(
doc = <span class="string">&quot;Reports whether the response of the delay values is linear.&quot;</span>,
has_linear_response_delay,
ecx,
<span class="number">2
</span>);
}
<span class="kw">impl </span>Debug <span class="kw">for </span>MemBwAllocationInfo {
<span class="kw">fn </span>fmt(<span class="kw-2">&amp;</span><span class="self">self</span>, f: <span class="kw-2">&amp;mut </span>Formatter&lt;<span class="lifetime">&#39;_</span>&gt;) -&gt; core::fmt::Result {
f.debug_struct(<span class="string">&quot;MemBwAllocationInfo&quot;</span>)
.field(<span class="string">&quot;max_hba_throttling&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.max_hba_throttling())
.field(<span class="string">&quot;highest_cos&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.highest_cos())
.field(
<span class="string">&quot;has_linear_response_delay&quot;</span>,
<span class="kw-2">&amp;</span><span class="self">self</span>.has_linear_response_delay(),
)
.finish()
}
}
<span class="doccomment">/// Intel SGX Capability Enumeration Leaf (LEAF=0x12).
///
/// Two sub-leafs: (EAX = 12H, ECX = 0 and ECX = 1)
///
/// # Platforms
/// ❌ AMD ✅ Intel
</span><span class="attribute">#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, derive(Serialize, Deserialize))]
</span><span class="kw">pub struct </span>SgxInfo {
<span class="attribute">#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, serde(skip))]
</span>read: CpuIdReader,
eax: u32,
ebx: u32,
_ecx: u32,
edx: u32,
eax1: u32,
ebx1: u32,
ecx1: u32,
edx1: u32,
}
<span class="kw">impl </span>SgxInfo {
<span class="macro">check_bit_fn!</span>(doc = <span class="string">&quot;Has SGX1 support.&quot;</span>, has_sgx1, eax, <span class="number">0</span>);
<span class="macro">check_bit_fn!</span>(doc = <span class="string">&quot;Has SGX2 support.&quot;</span>, has_sgx2, eax, <span class="number">1</span>);
<span class="macro">check_bit_fn!</span>(
doc = <span class="string">&quot;Supports ENCLV instruction leaves EINCVIRTCHILD, EDECVIRTCHILD, and ESETCONTEXT.&quot;</span>,
has_enclv_leaves_einvirtchild_edecvirtchild_esetcontext,
eax,
<span class="number">5
</span>);
<span class="macro">check_bit_fn!</span>(
doc = <span class="string">&quot;Supports ENCLS instruction leaves ETRACKC, ERDINFO, ELDBC, and ELDUC.&quot;</span>,
has_encls_leaves_etrackc_erdinfo_eldbc_elduc,
eax,
<span class="number">6
</span>);
<span class="doccomment">/// Bit vector of supported extended SGX features.
</span><span class="kw">pub fn </span>miscselect(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u32 {
<span class="self">self</span>.ebx
}
<span class="doccomment">/// The maximum supported enclave size in non-64-bit mode is 2^retval.
</span><span class="kw">pub fn </span>max_enclave_size_non_64bit(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u8 {
get_bits(<span class="self">self</span>.edx, <span class="number">0</span>, <span class="number">7</span>) <span class="kw">as </span>u8
}
<span class="doccomment">/// The maximum supported enclave size in 64-bit mode is 2^retval.
</span><span class="kw">pub fn </span>max_enclave_size_64bit(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u8 {
get_bits(<span class="self">self</span>.edx, <span class="number">8</span>, <span class="number">15</span>) <span class="kw">as </span>u8
}
<span class="doccomment">/// Reports the valid bits of SECS.ATTRIBUTES\[127:0\] that software can set with ECREATE.
</span><span class="kw">pub fn </span>secs_attributes(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; (u64, u64) {
<span class="kw">let </span>lower = <span class="self">self</span>.eax1 <span class="kw">as </span>u64 | (<span class="self">self</span>.ebx1 <span class="kw">as </span>u64) &lt;&lt; <span class="number">32</span>;
<span class="kw">let </span>upper = <span class="self">self</span>.ecx1 <span class="kw">as </span>u64 | (<span class="self">self</span>.edx1 <span class="kw">as </span>u64) &lt;&lt; <span class="number">32</span>;
(lower, upper)
}
<span class="doccomment">/// Iterator over SGX sub-leafs.
</span><span class="kw">pub fn </span>iter(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; SgxSectionIter {
SgxSectionIter {
read: <span class="self">self</span>.read,
current: <span class="number">2</span>,
}
}
}
<span class="kw">impl </span>Debug <span class="kw">for </span>SgxInfo {
<span class="kw">fn </span>fmt(<span class="kw-2">&amp;</span><span class="self">self</span>, f: <span class="kw-2">&amp;mut </span>Formatter&lt;<span class="lifetime">&#39;_</span>&gt;) -&gt; core::fmt::Result {
f.debug_struct(<span class="string">&quot;SgxInfo&quot;</span>)
.field(<span class="string">&quot;has_sgx1&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.has_sgx1())
.field(<span class="string">&quot;has_sgx2&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.has_sgx2())
.field(<span class="string">&quot;miscselect&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.miscselect())
.field(
<span class="string">&quot;max_enclave_size_non_64bit&quot;</span>,
<span class="kw-2">&amp;</span><span class="self">self</span>.max_enclave_size_non_64bit(),
)
.field(<span class="string">&quot;max_enclave_size_64bit&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.max_enclave_size_64bit())
.field(
<span class="string">&quot;has_encls_leaves_etrackc_erdinfo_eldbc_elduc&quot;</span>,
<span class="kw-2">&amp;</span><span class="self">self</span>.has_encls_leaves_etrackc_erdinfo_eldbc_elduc(),
)
.field(
<span class="string">&quot;has_enclv_leaves_einvirtchild_edecvirtchild_esetcontext&quot;</span>,
<span class="kw-2">&amp;</span><span class="self">self</span>.has_enclv_leaves_einvirtchild_edecvirtchild_esetcontext(),
)
.field(<span class="string">&quot;sgx_section_iter&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.iter())
.finish()
}
}
<span class="doccomment">/// Iterator over the SGX sub-leafs (ECX &gt;= 2).
</span><span class="attribute">#[derive(Clone)]
#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, derive(Serialize, Deserialize))]
</span><span class="kw">pub struct </span>SgxSectionIter {
<span class="attribute">#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, serde(skip))]
</span>read: CpuIdReader,
current: u32,
}
<span class="kw">impl </span>Iterator <span class="kw">for </span>SgxSectionIter {
<span class="kw">type </span>Item = SgxSectionInfo;
<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;SgxSectionInfo&gt; {
<span class="kw">let </span>res = <span class="self">self</span>.read.cpuid2(EAX_SGX, <span class="self">self</span>.current);
<span class="self">self</span>.current += <span class="number">1</span>;
<span class="kw">match </span>get_bits(res.eax, <span class="number">0</span>, <span class="number">3</span>) {
<span class="number">0b0001 </span>=&gt; <span class="prelude-val">Some</span>(SgxSectionInfo::Epc(EpcSection {
eax: res.eax,
ebx: res.ebx,
ecx: res.ecx,
edx: res.edx,
})),
<span class="kw">_ </span>=&gt; <span class="prelude-val">None</span>,
}
}
}
<span class="kw">impl </span>Debug <span class="kw">for </span>SgxSectionIter {
<span class="kw">fn </span>fmt(<span class="kw-2">&amp;</span><span class="self">self</span>, f: <span class="kw-2">&amp;mut </span>Formatter&lt;<span class="lifetime">&#39;_</span>&gt;) -&gt; core::fmt::Result {
<span class="kw">let </span><span class="kw-2">mut </span>debug = f.debug_list();
<span class="self">self</span>.clone().for_each(|<span class="kw-2">ref </span>item| {
debug.entry(item);
});
debug.finish()
}
}
<span class="doccomment">/// Intel SGX EPC Enumeration Leaf
///
/// Sub-leaves 2 or higher.
</span><span class="attribute">#[derive(Debug)]
#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, derive(Serialize, Deserialize))]
</span><span class="kw">pub enum </span>SgxSectionInfo {
<span class="comment">// This would be nice: https://github.com/rust-lang/rfcs/pull/1450
</span>Epc(EpcSection),
}
<span class="doccomment">/// EBX:EAX and EDX:ECX provide information on the Enclave Page Cache (EPC) section
</span><span class="attribute">#[derive(Debug)]
#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, derive(Serialize, Deserialize))]
</span><span class="kw">pub struct </span>EpcSection {
eax: u32,
ebx: u32,
ecx: u32,
edx: u32,
}
<span class="kw">impl </span>EpcSection {
<span class="doccomment">/// The physical address of the base of the EPC section
</span><span class="kw">pub fn </span>physical_base(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u64 {
<span class="kw">let </span>lower = (get_bits(<span class="self">self</span>.eax, <span class="number">12</span>, <span class="number">31</span>) &lt;&lt; <span class="number">12</span>) <span class="kw">as </span>u64;
<span class="kw">let </span>upper = (get_bits(<span class="self">self</span>.ebx, <span class="number">0</span>, <span class="number">19</span>) <span class="kw">as </span>u64) &lt;&lt; <span class="number">32</span>;
lower | upper
}
<span class="doccomment">/// Size of the corresponding EPC section within the Processor Reserved Memory.
</span><span class="kw">pub fn </span>size(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u64 {
<span class="kw">let </span>lower = (get_bits(<span class="self">self</span>.ecx, <span class="number">12</span>, <span class="number">31</span>) &lt;&lt; <span class="number">12</span>) <span class="kw">as </span>u64;
<span class="kw">let </span>upper = (get_bits(<span class="self">self</span>.edx, <span class="number">0</span>, <span class="number">19</span>) <span class="kw">as </span>u64) &lt;&lt; <span class="number">32</span>;
lower | upper
}
}
<span class="doccomment">/// Intel Processor Trace Information (LEAF=0x14).
///
/// # Platforms
/// ❌ AMD ✅ Intel
</span><span class="attribute">#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, derive(Serialize, Deserialize))]
</span><span class="kw">pub struct </span>ProcessorTraceInfo {
_eax: u32,
ebx: u32,
ecx: u32,
_edx: u32,
leaf1: <span class="prelude-ty">Option</span>&lt;CpuIdResult&gt;,
}
<span class="kw">impl </span>ProcessorTraceInfo {
<span class="comment">// EBX features
</span><span class="macro">check_bit_fn!</span>(
doc = <span class="string">&quot;If true, Indicates that IA32_RTIT_CTL.CR3Filter can be set to 1, and \
that IA32_RTIT_CR3_MATCH MSR can be accessed.&quot;</span>,
has_rtit_cr3_match,
ebx,
<span class="number">0
</span>);
<span class="macro">check_bit_fn!</span>(
doc = <span class="string">&quot;If true, Indicates support of Configurable PSB and Cycle-Accurate Mode.&quot;</span>,
has_configurable_psb_and_cycle_accurate_mode,
ebx,
<span class="number">1
</span>);
<span class="macro">check_bit_fn!</span>(
doc = <span class="string">&quot;If true, Indicates support of IP Filtering, TraceStop filtering, and \
preservation of Intel PT MSRs across warm reset.&quot;</span>,
has_ip_tracestop_filtering,
ebx,
<span class="number">2
</span>);
<span class="macro">check_bit_fn!</span>(
doc = <span class="string">&quot;If true, Indicates support of MTC timing packet and suppression of \
COFI-based packets.&quot;</span>,
has_mtc_timing_packet_coefi_suppression,
ebx,
<span class="number">3
</span>);
<span class="macro">check_bit_fn!</span>(
doc = <span class="string">&quot;Indicates support of PTWRITE. Writes can set IA32_RTIT_CTL\\[12\\] (PTWEn \
and IA32_RTIT_CTL\\[5\\] (FUPonPTW), and PTWRITE can generate packets&quot;</span>,
has_ptwrite,
ebx,
<span class="number">4
</span>);
<span class="macro">check_bit_fn!</span>(
doc = <span class="string">&quot;Support of Power Event Trace. Writes can set IA32_RTIT_CTL\\[4\\] (PwrEvtEn) \
enabling Power Event Trace packet generation.&quot;</span>,
has_power_event_trace,
ebx,
<span class="number">5
</span>);
<span class="comment">// ECX features
</span><span class="macro">check_bit_fn!</span>(
doc = <span class="string">&quot;If true, Tracing can be enabled with IA32_RTIT_CTL.ToPA = 1, hence \
utilizing the ToPA output scheme; IA32_RTIT_OUTPUT_BASE and \
IA32_RTIT_OUTPUT_MASK_PTRS MSRs can be accessed.&quot;</span>,
has_topa,
ecx,
<span class="number">0
</span>);
<span class="macro">check_bit_fn!</span>(
doc = <span class="string">&quot;If true, ToPA tables can hold any number of output entries, up to the \
maximum allowed by the MaskOrTableOffset field of \
IA32_RTIT_OUTPUT_MASK_PTRS.&quot;</span>,
has_topa_maximum_entries,
ecx,
<span class="number">1
</span>);
<span class="macro">check_bit_fn!</span>(
doc = <span class="string">&quot;If true, Indicates support of Single-Range Output scheme.&quot;</span>,
has_single_range_output_scheme,
ecx,
<span class="number">2
</span>);
<span class="macro">check_bit_fn!</span>(
doc = <span class="string">&quot;If true, Indicates support of output to Trace Transport subsystem.&quot;</span>,
has_trace_transport_subsystem,
ecx,
<span class="number">3
</span>);
<span class="macro">check_bit_fn!</span>(
doc = <span class="string">&quot;If true, Generated packets which contain IP payloads have LIP values, \
which include the CS base component.&quot;</span>,
has_lip_with_cs_base,
ecx,
<span class="number">31
</span>);
<span class="doccomment">/// Number of configurable Address Ranges for filtering (Bits 2:0).
</span><span class="kw">pub fn </span>configurable_address_ranges(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u8 {
<span class="self">self</span>.leaf1.map_or(<span class="number">0</span>, |res| get_bits(res.eax, <span class="number">0</span>, <span class="number">2</span>) <span class="kw">as </span>u8)
}
<span class="doccomment">/// Bitmap of supported MTC period encodings (Bit 31:16).
</span><span class="kw">pub fn </span>supported_mtc_period_encodings(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u16 {
<span class="self">self</span>.leaf1.map_or(<span class="number">0</span>, |res| get_bits(res.eax, <span class="number">16</span>, <span class="number">31</span>) <span class="kw">as </span>u16)
}
<span class="doccomment">/// Bitmap of supported Cycle Threshold value encodings (Bits 15-0).
</span><span class="kw">pub fn </span>supported_cycle_threshold_value_encodings(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u16 {
<span class="self">self</span>.leaf1.map_or(<span class="number">0</span>, |res| get_bits(res.ebx, <span class="number">0</span>, <span class="number">15</span>) <span class="kw">as </span>u16)
}
<span class="doccomment">/// Bitmap of supported Configurable PSB frequency encodings (Bit 31:16)
</span><span class="kw">pub fn </span>supported_psb_frequency_encodings(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u16 {
<span class="self">self</span>.leaf1.map_or(<span class="number">0</span>, |res| get_bits(res.ebx, <span class="number">16</span>, <span class="number">31</span>) <span class="kw">as </span>u16)
}
}
<span class="kw">impl </span>Debug <span class="kw">for </span>ProcessorTraceInfo {
<span class="kw">fn </span>fmt(<span class="kw-2">&amp;</span><span class="self">self</span>, f: <span class="kw-2">&amp;mut </span>Formatter&lt;<span class="lifetime">&#39;_</span>&gt;) -&gt; core::fmt::Result {
f.debug_struct(<span class="string">&quot;ProcessorTraceInfo&quot;</span>)
.field(
<span class="string">&quot;configurable_address_ranges&quot;</span>,
<span class="kw-2">&amp;</span><span class="self">self</span>.configurable_address_ranges(),
)
.field(
<span class="string">&quot;supported_mtc_period_encodings&quot;</span>,
<span class="kw-2">&amp;</span><span class="self">self</span>.supported_mtc_period_encodings(),
)
.field(
<span class="string">&quot;supported_cycle_threshold_value_encodings&quot;</span>,
<span class="kw-2">&amp;</span><span class="self">self</span>.supported_cycle_threshold_value_encodings(),
)
.field(
<span class="string">&quot;supported_psb_frequency_encodings&quot;</span>,
<span class="kw-2">&amp;</span><span class="self">self</span>.supported_psb_frequency_encodings(),
)
.finish()
}
}
<span class="doccomment">/// Time Stamp Counter/Core Crystal Clock Information (LEAF=0x15).
///
/// # Platforms
/// ❌ AMD ✅ Intel
</span><span class="attribute">#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, derive(Serialize, Deserialize))]
</span><span class="kw">pub struct </span>TscInfo {
eax: u32,
ebx: u32,
ecx: u32,
}
<span class="kw">impl </span>fmt::Debug <span class="kw">for </span>TscInfo {
<span class="kw">fn </span>fmt(<span class="kw-2">&amp;</span><span class="self">self</span>, f: <span class="kw-2">&amp;mut </span>fmt::Formatter) -&gt; fmt::Result {
f.debug_struct(<span class="string">&quot;TscInfo&quot;</span>)
.field(<span class="string">&quot;denominator&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.denominator())
.field(<span class="string">&quot;numerator&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.numerator())
.field(<span class="string">&quot;nominal_frequency&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.nominal_frequency())
.field(<span class="string">&quot;tsc_frequency&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.tsc_frequency())
.finish()
}
}
<span class="kw">impl </span>TscInfo {
<span class="doccomment">/// An unsigned integer which is the denominator of the TSC/”core crystal clock” ratio.
</span><span class="kw">pub fn </span>denominator(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u32 {
<span class="self">self</span>.eax
}
<span class="doccomment">/// An unsigned integer which is the numerator of the TSC/”core crystal clock” ratio.
///
/// If this is 0, the TSC/”core crystal clock” ratio is not enumerated.
</span><span class="kw">pub fn </span>numerator(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u32 {
<span class="self">self</span>.ebx
}
<span class="doccomment">/// An unsigned integer which is the nominal frequency of the core crystal clock in Hz.
///
/// If this is 0, the nominal core crystal clock frequency is not enumerated.
</span><span class="kw">pub fn </span>nominal_frequency(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u32 {
<span class="self">self</span>.ecx
}
<span class="doccomment">/// “TSC frequency” = “core crystal clock frequency” * EBX/EAX.
</span><span class="kw">pub fn </span>tsc_frequency(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;u64&gt; {
<span class="comment">// In some case TscInfo is a valid leaf, but the values reported are still 0
// we should avoid a division by zero in case denominator ends up being 0.
</span><span class="kw">if </span><span class="self">self</span>.nominal_frequency() == <span class="number">0 </span>|| <span class="self">self</span>.numerator() == <span class="number">0 </span>|| <span class="self">self</span>.denominator() == <span class="number">0 </span>{
<span class="kw">return </span><span class="prelude-val">None</span>;
}
<span class="prelude-val">Some</span>(<span class="self">self</span>.nominal_frequency() <span class="kw">as </span>u64 * <span class="self">self</span>.numerator() <span class="kw">as </span>u64 / <span class="self">self</span>.denominator() <span class="kw">as </span>u64)
}
}
<span class="doccomment">/// Processor Frequency Information (LEAF=0x16).
///
/// # Platforms
/// ❌ AMD ✅ Intel
</span><span class="attribute">#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, derive(Serialize, Deserialize))]
</span><span class="kw">pub struct </span>ProcessorFrequencyInfo {
eax: u32,
ebx: u32,
ecx: u32,
}
<span class="kw">impl </span>ProcessorFrequencyInfo {
<span class="doccomment">/// Processor Base Frequency (in MHz).
</span><span class="kw">pub fn </span>processor_base_frequency(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u16 {
get_bits(<span class="self">self</span>.eax, <span class="number">0</span>, <span class="number">15</span>) <span class="kw">as </span>u16
}
<span class="doccomment">/// Maximum Frequency (in MHz).
</span><span class="kw">pub fn </span>processor_max_frequency(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u16 {
get_bits(<span class="self">self</span>.ebx, <span class="number">0</span>, <span class="number">15</span>) <span class="kw">as </span>u16
}
<span class="doccomment">/// Bus (Reference) Frequency (in MHz).
</span><span class="kw">pub fn </span>bus_frequency(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u16 {
get_bits(<span class="self">self</span>.ecx, <span class="number">0</span>, <span class="number">15</span>) <span class="kw">as </span>u16
}
}
<span class="kw">impl </span>fmt::Debug <span class="kw">for </span>ProcessorFrequencyInfo {
<span class="kw">fn </span>fmt(<span class="kw-2">&amp;</span><span class="self">self</span>, f: <span class="kw-2">&amp;mut </span>fmt::Formatter) -&gt; fmt::Result {
f.debug_struct(<span class="string">&quot;ProcessorFrequencyInfo&quot;</span>)
.field(<span class="string">&quot;processor_base_frequency&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.processor_base_frequency())
.field(<span class="string">&quot;processor_max_frequency&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.processor_max_frequency())
.field(<span class="string">&quot;bus_frequency&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.bus_frequency())
.finish()
}
}
<span class="doccomment">/// Deterministic Address Translation Structure Iterator (LEAF=0x18).
///
/// # Platforms
/// ❌ AMD ✅ Intel
</span><span class="attribute">#[derive(Clone)]
#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, derive(Serialize, Deserialize))]
</span><span class="kw">pub struct </span>DatIter {
<span class="attribute">#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, serde(skip))]
</span>read: CpuIdReader,
current: u32,
count: u32,
}
<span class="kw">impl </span>Iterator <span class="kw">for </span>DatIter {
<span class="kw">type </span>Item = DatInfo;
<span class="doccomment">/// Iterate over each sub-leaf with an address translation structure.
</span><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;DatInfo&gt; {
<span class="kw">loop </span>{
<span class="comment">// Sub-leaf index n is invalid if n exceeds the value that sub-leaf 0 returns in EAX
</span><span class="kw">if </span><span class="self">self</span>.current &gt; <span class="self">self</span>.count {
<span class="kw">return </span><span class="prelude-val">None</span>;
}
<span class="kw">let </span>res = <span class="self">self
</span>.read
.cpuid2(EAX_DETERMINISTIC_ADDRESS_TRANSLATION_INFO, <span class="self">self</span>.current);
<span class="self">self</span>.current += <span class="number">1</span>;
<span class="comment">// A sub-leaf index is also invalid if EDX[4:0] returns 0.
</span><span class="kw">if </span>get_bits(res.edx, <span class="number">0</span>, <span class="number">4</span>) == <span class="number">0 </span>{
<span class="comment">// Valid sub-leaves do not need to be contiguous or in any particular order.
// A valid sub-leaf may be in a higher input ECX value than an invalid sub-leaf
// or than a valid sub-leaf of a higher or lower-level struc-ture
</span><span class="kw">continue</span>;
}
<span class="kw">return </span><span class="prelude-val">Some</span>(DatInfo {
_eax: res.eax,
ebx: res.ebx,
ecx: res.ecx,
edx: res.edx,
});
}
}
}
<span class="kw">impl </span>Debug <span class="kw">for </span>DatIter {
<span class="kw">fn </span>fmt(<span class="kw-2">&amp;</span><span class="self">self</span>, f: <span class="kw-2">&amp;mut </span>Formatter&lt;<span class="lifetime">&#39;_</span>&gt;) -&gt; fmt::Result {
<span class="kw">let </span><span class="kw-2">mut </span>debug = f.debug_list();
<span class="self">self</span>.clone().for_each(|<span class="kw-2">ref </span>item| {
debug.entry(item);
});
debug.finish()
}
}
<span class="doccomment">/// Deterministic Address Translation Structure
</span><span class="attribute">#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, derive(Serialize, Deserialize))]
</span><span class="kw">pub struct </span>DatInfo {
_eax: u32,
ebx: u32,
ecx: u32,
edx: u32,
}
<span class="kw">impl </span>DatInfo {
<span class="macro">check_bit_fn!</span>(
doc = <span class="string">&quot;4K page size entries supported by this structure&quot;</span>,
has_4k_entries,
ebx,
<span class="number">0
</span>);
<span class="macro">check_bit_fn!</span>(
doc = <span class="string">&quot;2MB page size entries supported by this structure&quot;</span>,
has_2mb_entries,
ebx,
<span class="number">1
</span>);
<span class="macro">check_bit_fn!</span>(
doc = <span class="string">&quot;4MB page size entries supported by this structure&quot;</span>,
has_4mb_entries,
ebx,
<span class="number">2
</span>);
<span class="macro">check_bit_fn!</span>(
doc = <span class="string">&quot;1GB page size entries supported by this structure&quot;</span>,
has_1gb_entries,
ebx,
<span class="number">3
</span>);
<span class="macro">check_bit_fn!</span>(
doc = <span class="string">&quot;Fully associative structure&quot;</span>,
is_fully_associative,
edx,
<span class="number">8
</span>);
<span class="doccomment">/// Partitioning (0: Soft partitioning between the logical processors sharing this structure).
</span><span class="kw">pub fn </span>partitioning(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u8 {
get_bits(<span class="self">self</span>.ebx, <span class="number">8</span>, <span class="number">10</span>) <span class="kw">as </span>u8
}
<span class="doccomment">/// Ways of associativity.
</span><span class="kw">pub fn </span>ways(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u16 {
get_bits(<span class="self">self</span>.ebx, <span class="number">16</span>, <span class="number">31</span>) <span class="kw">as </span>u16
}
<span class="doccomment">/// Number of Sets.
</span><span class="kw">pub fn </span>sets(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u32 {
<span class="self">self</span>.ecx
}
<span class="doccomment">/// Translation cache type field.
</span><span class="kw">pub fn </span>cache_type(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; DatType {
<span class="kw">match </span>get_bits(<span class="self">self</span>.edx, <span class="number">0</span>, <span class="number">4</span>) <span class="kw">as </span>u8 {
<span class="number">0b00001 </span>=&gt; DatType::DataTLB,
<span class="number">0b00010 </span>=&gt; DatType::InstructionTLB,
<span class="number">0b00011 </span>=&gt; DatType::UnifiedTLB,
<span class="number">0b00000 </span>=&gt; DatType::Null, <span class="comment">// should never be returned as this indicates invalid struct!
</span><span class="number">0b00100 </span>=&gt; DatType::LoadOnly,
<span class="number">0b00101 </span>=&gt; DatType::StoreOnly,
<span class="kw">_ </span>=&gt; DatType::Unknown,
}
}
<span class="doccomment">/// Translation cache level (starts at 1)
</span><span class="kw">pub fn </span>cache_level(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u8 {
get_bits(<span class="self">self</span>.edx, <span class="number">5</span>, <span class="number">7</span>) <span class="kw">as </span>u8
}
<span class="doccomment">/// Maximum number of addressable IDs for logical processors sharing this translation cache
</span><span class="kw">pub fn </span>max_addressable_ids(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u16 {
<span class="comment">// Add one to the return value to get the result:
</span>(get_bits(<span class="self">self</span>.edx, <span class="number">14</span>, <span class="number">25</span>) + <span class="number">1</span>) <span class="kw">as </span>u16
}
}
<span class="kw">impl </span>Debug <span class="kw">for </span>DatInfo {
<span class="kw">fn </span>fmt(<span class="kw-2">&amp;</span><span class="self">self</span>, f: <span class="kw-2">&amp;mut </span>Formatter&lt;<span class="lifetime">&#39;_</span>&gt;) -&gt; fmt::Result {
f.debug_struct(<span class="string">&quot;DatInfo&quot;</span>)
.field(<span class="string">&quot;has_4k_entries&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.has_4k_entries())
.field(<span class="string">&quot;has_2mb_entries&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.has_2mb_entries())
.field(<span class="string">&quot;has_4mb_entries&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.has_4mb_entries())
.field(<span class="string">&quot;has_1gb_entries&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.has_1gb_entries())
.field(<span class="string">&quot;is_fully_associative&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.is_fully_associative())
.finish()
}
}
<span class="doccomment">/// Deterministic Address Translation cache type (EDX bits 04 -- 00)
</span><span class="attribute">#[derive(Eq, PartialEq, Debug)]
#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, derive(Serialize, Deserialize))]
</span><span class="kw">pub enum </span>DatType {
<span class="doccomment">/// Null (indicates this sub-leaf is not valid).
</span>Null = <span class="number">0b00000</span>,
DataTLB = <span class="number">0b00001</span>,
InstructionTLB = <span class="number">0b00010</span>,
<span class="doccomment">/// Some unified TLBs will allow a single TLB entry to satisfy data read/write
/// and instruction fetches. Others will require separate entries (e.g., one
/// loaded on data read/write and another loaded on an instruction fetch) .
/// Please see the Intel® 64 and IA-32 Architectures Optimization Reference Manual
/// for details of a particular product.
</span>UnifiedTLB = <span class="number">0b00011</span>,
LoadOnly = <span class="number">0b0100</span>,
StoreOnly = <span class="number">0b0101</span>,
Unknown,
}
<span class="kw">impl </span>fmt::Display <span class="kw">for </span>DatType {
<span class="kw">fn </span>fmt(<span class="kw-2">&amp;</span><span class="self">self</span>, f: <span class="kw-2">&amp;mut </span>Formatter&lt;<span class="lifetime">&#39;_</span>&gt;) -&gt; fmt::Result {
<span class="kw">let </span>t = <span class="kw">match </span><span class="self">self </span>{
DatType::Null =&gt; <span class="string">&quot;invalid (0)&quot;</span>,
DatType::DataTLB =&gt; <span class="string">&quot;Data TLB&quot;</span>,
DatType::InstructionTLB =&gt; <span class="string">&quot;Instruction TLB&quot;</span>,
DatType::UnifiedTLB =&gt; <span class="string">&quot;Unified TLB&quot;</span>,
DatType::LoadOnly =&gt; <span class="string">&quot;Load Only&quot;</span>,
DatType::StoreOnly =&gt; <span class="string">&quot;Store Only&quot;</span>,
DatType::Unknown =&gt; <span class="string">&quot;Unknown&quot;</span>,
};
f.write_str(t)
}
}
<span class="doccomment">/// SoC vendor specific information (LEAF=0x17).
///
/// # Platforms
/// ❌ AMD ✅ Intel
</span><span class="attribute">#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, derive(Serialize, Deserialize))]
</span><span class="kw">pub struct </span>SoCVendorInfo {
<span class="attribute">#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, serde(skip))]
</span>read: CpuIdReader,
<span class="doccomment">/// MaxSOCID_Index
</span>eax: u32,
ebx: u32,
ecx: u32,
edx: u32,
}
<span class="kw">impl </span>SoCVendorInfo {
<span class="kw">pub fn </span>get_soc_vendor_id(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u16 {
get_bits(<span class="self">self</span>.ebx, <span class="number">0</span>, <span class="number">15</span>) <span class="kw">as </span>u16
}
<span class="kw">pub fn </span>get_project_id(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u32 {
<span class="self">self</span>.ecx
}
<span class="kw">pub fn </span>get_stepping_id(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; u32 {
<span class="self">self</span>.edx
}
<span class="kw">pub fn </span>get_vendor_brand(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;SoCVendorBrand&gt; {
<span class="comment">// Leaf 17H is valid if MaxSOCID_Index &gt;= 3.
</span><span class="kw">if </span><span class="self">self</span>.eax &gt;= <span class="number">3 </span>{
<span class="kw">let </span>r1 = <span class="self">self</span>.read.cpuid2(EAX_SOC_VENDOR_INFO, <span class="number">1</span>);
<span class="kw">let </span>r2 = <span class="self">self</span>.read.cpuid2(EAX_SOC_VENDOR_INFO, <span class="number">2</span>);
<span class="kw">let </span>r3 = <span class="self">self</span>.read.cpuid2(EAX_SOC_VENDOR_INFO, <span class="number">3</span>);
<span class="prelude-val">Some</span>(SoCVendorBrand { data: [r1, r2, r3] })
} <span class="kw">else </span>{
<span class="prelude-val">None
</span>}
}
<span class="kw">pub fn </span>get_vendor_attributes(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;SoCVendorAttributesIter&gt; {
<span class="kw">if </span><span class="self">self</span>.eax &gt; <span class="number">3 </span>{
<span class="prelude-val">Some</span>(SoCVendorAttributesIter {
read: <span class="self">self</span>.read,
count: <span class="self">self</span>.eax,
current: <span class="number">3</span>,
})
} <span class="kw">else </span>{
<span class="prelude-val">None
</span>}
}
}
<span class="kw">impl </span>fmt::Debug <span class="kw">for </span>SoCVendorInfo {
<span class="kw">fn </span>fmt(<span class="kw-2">&amp;</span><span class="self">self</span>, f: <span class="kw-2">&amp;mut </span>fmt::Formatter) -&gt; fmt::Result {
f.debug_struct(<span class="string">&quot;SoCVendorInfo&quot;</span>)
.field(<span class="string">&quot;soc_vendor_id&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.get_soc_vendor_id())
.field(<span class="string">&quot;project_id&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.get_project_id())
.field(<span class="string">&quot;stepping_id&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.get_stepping_id())
.field(<span class="string">&quot;vendor_brand&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.get_vendor_brand())
.field(<span class="string">&quot;vendor_attributes&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.get_vendor_attributes())
.finish()
}
}
<span class="doccomment">/// Iterator for SoC vendor attributes.
</span><span class="attribute">#[derive(Debug)]
#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, derive(Serialize, Deserialize))]
</span><span class="kw">pub struct </span>SoCVendorAttributesIter {
<span class="attribute">#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, serde(skip))]
</span>read: CpuIdReader,
count: u32,
current: u32,
}
<span class="kw">impl </span>Iterator <span class="kw">for </span>SoCVendorAttributesIter {
<span class="kw">type </span>Item = CpuIdResult;
<span class="doccomment">/// Iterate over all SoC vendor specific attributes.
</span><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;CpuIdResult&gt; {
<span class="kw">if </span><span class="self">self</span>.current &gt; <span class="self">self</span>.count {
<span class="kw">return </span><span class="prelude-val">None</span>;
}
<span class="self">self</span>.count += <span class="number">1</span>;
<span class="prelude-val">Some</span>(<span class="self">self</span>.read.cpuid2(EAX_SOC_VENDOR_INFO, <span class="self">self</span>.count))
}
}
<span class="doccomment">/// A vendor brand string as queried from the cpuid leaf.
</span><span class="attribute">#[derive(Debug, PartialEq, Eq)]
#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, derive(Serialize, Deserialize))]
#[repr(C)]
</span><span class="kw">pub struct </span>SoCVendorBrand {
data: [CpuIdResult; <span class="number">3</span>],
}
<span class="kw">impl </span>SoCVendorBrand {
<span class="doccomment">/// Return the SocVendorBrand as a string.
</span><span class="kw">pub fn </span>as_str(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="kw-2">&amp;</span>str {
<span class="kw">let </span>brand_string_start = <span class="self">self </span><span class="kw">as </span><span class="kw-2">*const </span>SoCVendorBrand <span class="kw">as </span><span class="kw-2">*const </span>u8;
<span class="kw">let </span>slice = <span class="kw">unsafe </span>{
<span class="comment">// Safety: SoCVendorBrand is laid out with repr(C).
</span>slice::from_raw_parts(brand_string_start, size_of::&lt;SoCVendorBrand&gt;())
};
str::from_utf8(slice).unwrap_or(<span class="string">&quot;InvalidSoCVendorString&quot;</span>)
}
<span class="attribute">#[deprecated(
since = <span class="string">&quot;10.0.0&quot;</span>,
note = <span class="string">&quot;Use idiomatic function name `as_str` instead&quot;
</span>)]
</span><span class="kw">pub fn </span>as_string(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="kw-2">&amp;</span>str {
<span class="self">self</span>.as_str()
}
}
<span class="kw">impl </span>fmt::Display <span class="kw">for </span>SoCVendorBrand {
<span class="kw">fn </span>fmt(<span class="kw-2">&amp;</span><span class="self">self</span>, f: <span class="kw-2">&amp;mut </span>fmt::Formatter) -&gt; fmt::Result {
<span class="macro">write!</span>(f, <span class="string">&quot;{}&quot;</span>, <span class="self">self</span>.as_str())
}
}
<span class="doccomment">/// Information about Hypervisor (LEAF=0x4000_0001)
///
/// More information about this semi-official leaf can be found here
/// &lt;https://lwn.net/Articles/301888/&gt;
</span><span class="attribute">#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, derive(Serialize, Deserialize))]
</span><span class="kw">pub struct </span>HypervisorInfo {
<span class="attribute">#[cfg_attr(feature = <span class="string">&quot;serialize&quot;</span>, serde(skip))]
</span>read: CpuIdReader,
res: CpuIdResult,
}
<span class="kw">impl </span>fmt::Debug <span class="kw">for </span>HypervisorInfo {
<span class="kw">fn </span>fmt(<span class="kw-2">&amp;</span><span class="self">self</span>, f: <span class="kw-2">&amp;mut </span>fmt::Formatter) -&gt; fmt::Result {
f.debug_struct(<span class="string">&quot;HypervisorInfo&quot;</span>)
.field(<span class="string">&quot;identify&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.identify())
.field(<span class="string">&quot;tsc_frequency&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.tsc_frequency())
.field(<span class="string">&quot;apic_frequency&quot;</span>, <span class="kw-2">&amp;</span><span class="self">self</span>.apic_frequency())
.finish()
}
}
<span class="doccomment">/// Identifies the different Hypervisor products.
</span><span class="attribute">#[derive(Debug, Eq, PartialEq)]
</span><span class="kw">pub enum </span>Hypervisor {
Xen,
VMware,
HyperV,
KVM,
<span class="doccomment">/// QEMU is the hypervisor identity when QEMU is used
/// without an accelerator, such as KVM.
</span>QEMU,
Bhyve,
QNX,
ACRN,
Unknown(u32, u32, u32),
}
<span class="kw">impl </span>HypervisorInfo {
<span class="doccomment">/// Returns the identity of the [`Hypervisor`].
///
/// ## Technical Background
///
/// The value is a 12-byte (12 character) fixed-length ASCII string.
///
/// Usually all of these IDs can be found in the original source code on
/// Github relatively easy (if the project is open source). Once you
/// have an ID, you find cumulated lists with all kinds of IDs on Github
/// relatively easy.
</span><span class="kw">pub fn </span>identify(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; Hypervisor {
<span class="kw">match </span>(<span class="self">self</span>.res.ebx, <span class="self">self</span>.res.ecx, <span class="self">self</span>.res.edx) {
<span class="comment">// &quot;VMwareVMware&quot; (0x56 =&gt; V, 0x4d =&gt; M, ...)
</span>(<span class="number">0x61774d56</span>, <span class="number">0x4d566572</span>, <span class="number">0x65726177</span>) =&gt; Hypervisor::VMware,
<span class="comment">// &quot;XenVMMXenVMM&quot;
</span>(<span class="number">0x566e6558</span>, <span class="number">0x65584d4d</span>, <span class="number">0x4d4d566e</span>) =&gt; Hypervisor::Xen,
<span class="comment">// &quot;Microsoft Hv&quot;
</span>(<span class="number">0x7263694d</span>, <span class="number">0x666f736f</span>, <span class="number">0x76482074</span>) =&gt; Hypervisor::HyperV,
<span class="comment">// &quot;KVMKVMKVM\0\0\0&quot;
</span>(<span class="number">0x4b4d564b</span>, <span class="number">0x564b4d56</span>, <span class="number">0x0000004d</span>) =&gt; Hypervisor::KVM,
<span class="comment">// &quot;TCGTCGTCGTCG&quot;
// see https://github.com/qemu/qemu/blob/6512fa497c2fa9751b9d774ab32d87a9764d1958/target/i386/cpu.c
</span>(<span class="number">0x54474354</span>, <span class="number">0x43544743</span>, <span class="number">0x47435447</span>) =&gt; Hypervisor::QEMU,
<span class="comment">// &quot;bhyve bhyve &quot;
// found this in another library (&quot;heim-virt&quot;)
</span>(<span class="number">0x76796862</span>, <span class="number">0x68622065</span>, <span class="number">0x20657679</span>) =&gt; Hypervisor::Bhyve,
<span class="comment">// &quot;BHyVE BHyVE &quot;
// But this value is in the original source code. To be safe, we keep both.
// See https://github.com/lattera/bhyve/blob/5946a9115d2771a1d27f14a835c7fbc05b30f7f9/sys/amd64/vmm/x86.c#L165
</span>(<span class="number">0x56794842</span>, <span class="number">0x48422045</span>, <span class="number">0x20455679</span>) =&gt; Hypervisor::Bhyve,
<span class="comment">// &quot;QNXQVMBSQG&quot;
// This can be verified in multiple Git repos (e.g. by Intel)
// https://github.com/search?q=QNXQVMBSQG&amp;type=code
</span>(<span class="number">0x51584e51</span>, <span class="number">0x53424d56</span>, <span class="number">0x00004751</span>) =&gt; Hypervisor::QNX,
<span class="comment">// &quot;ACRNACRNACRN&quot;
</span>(<span class="number">0x4e524341</span>, <span class="number">0x4e524341</span>, <span class="number">0x4e524341</span>) =&gt; Hypervisor::ACRN,
(ebx, ecx, edx) =&gt; Hypervisor::Unknown(ebx, ecx, edx),
}
}
<span class="doccomment">/// TSC frequency in kHz.
</span><span class="kw">pub fn </span>tsc_frequency(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;u32&gt; {
<span class="comment">// vm aware tsc frequency retrieval:
// # EAX: (Virtual) TSC frequency in kHz.
</span><span class="kw">if </span><span class="self">self</span>.res.eax &gt;= <span class="number">0x40000010 </span>{
<span class="kw">let </span>virt_tinfo = <span class="self">self</span>.read.cpuid2(<span class="number">0x40000010</span>, <span class="number">0</span>);
<span class="prelude-val">Some</span>(virt_tinfo.eax)
} <span class="kw">else </span>{
<span class="prelude-val">None
</span>}
}
<span class="doccomment">/// (Virtual) Bus (local apic timer) frequency in kHz.
</span><span class="kw">pub fn </span>apic_frequency(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;u32&gt; {
<span class="comment">// # EBX: (Virtual) Bus (local apic timer) frequency in kHz.
</span><span class="kw">if </span><span class="self">self</span>.res.eax &gt;= <span class="number">0x40000010 </span>{
<span class="kw">let </span>virt_tinfo = <span class="self">self</span>.read.cpuid2(<span class="number">0x40000010</span>, <span class="number">0</span>);
<span class="prelude-val">Some</span>(virt_tinfo.ebx)
} <span class="kw">else </span>{
<span class="prelude-val">None
</span>}
}
}
<span class="attribute">#[cfg(doctest)]
</span><span class="kw">mod </span>test_readme {
<span class="macro">macro_rules! </span>external_doc_test {
(<span class="macro-nonterminal">$x</span>:expr) =&gt; {
<span class="attribute">#[doc = <span class="macro-nonterminal">$x</span>]
</span><span class="kw">extern </span><span class="string">&quot;C&quot; </span>{}
};
}
<span class="macro">external_doc_test!</span>(<span class="macro">include_str!</span>(<span class="string">&quot;../README.md&quot;</span>));
}
</code></pre></div>
</section></div></main><div id="rustdoc-vars" data-root-path="../../" data-current-crate="raw_cpuid" data-themes="ayu,dark,light" data-resource-suffix="" data-rustdoc-version="1.66.0-nightly (5c8bff74b 2022-10-21)" ></div></body></html>