From 83f84a28d2fcf3afcc2a01f3d60c465609c90b12 Mon Sep 17 00:00:00 2001 From: Hamdy Abou El Anein Date: Tue, 3 Nov 2026 12:26:24 +0100 Subject: [PATCH] fix(security): resolve RUSTSEC-2026-0253 by upgrading lru --- Cargo.lock | 25 +- Cargo.toml | 6 + vendor/num-prime/COPYING | 5 + vendor/num-prime/Cargo.toml | 112 + vendor/num-prime/LICENSE-APACHE | 176 + vendor/num-prime/LICENSE-MIT | 23 + vendor/num-prime/PATCH-NOTES.md | 13 + vendor/num-prime/README.md | 38 + vendor/num-prime/src/buffer.rs | 929 ++ vendor/num-prime/src/factor.rs | 582 + vendor/num-prime/src/integer.rs | 391 + vendor/num-prime/src/lib.rs | 93 + vendor/num-prime/src/mint.rs | 1211 ++ vendor/num-prime/src/montgomery.rs | 492 + vendor/num-prime/src/nt_funcs.rs | 1731 +++ vendor/num-prime/src/primality.rs | 643 + vendor/num-prime/src/rand.rs | 349 + vendor/num-prime/src/splitmix64.rs | 61 + vendor/num-prime/src/tables.rs | 17911 +++++++++++++++++++++++++++ vendor/num-prime/src/traits.rs | 455 + vendor/num-prime/src/util.rs | 9 + 21 files changed, 25236 insertions(+), 19 deletions(-) create mode 100644 vendor/num-prime/COPYING create mode 100644 vendor/num-prime/Cargo.toml create mode 100644 vendor/num-prime/LICENSE-APACHE create mode 100644 vendor/num-prime/LICENSE-MIT create mode 100644 vendor/num-prime/PATCH-NOTES.md create mode 100644 vendor/num-prime/README.md create mode 100644 vendor/num-prime/src/buffer.rs create mode 100644 vendor/num-prime/src/factor.rs create mode 100644 vendor/num-prime/src/integer.rs create mode 100644 vendor/num-prime/src/lib.rs create mode 100644 vendor/num-prime/src/mint.rs create mode 100644 vendor/num-prime/src/montgomery.rs create mode 100644 vendor/num-prime/src/nt_funcs.rs create mode 100644 vendor/num-prime/src/primality.rs create mode 100644 vendor/num-prime/src/rand.rs create mode 100644 vendor/num-prime/src/splitmix64.rs create mode 100644 vendor/num-prime/src/tables.rs create mode 100644 vendor/num-prime/src/traits.rs create mode 100644 vendor/num-prime/src/util.rs diff --git a/Cargo.lock b/Cargo.lock index 4a6d70c..68cbc83 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -815,7 +815,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c54e03a951783e8b327515db3f2a2fd0e3bed362a96b066f341ce66ed49b4ead" dependencies = [ "data-encoding", - "syn 2.0.119", + "syn 3.0.9", ] [[package]] @@ -1193,17 +1193,6 @@ dependencies = [ "zerocopy", ] -[[package]] -name = "hashbrown" -version = "0.16.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100" -dependencies = [ - "allocator-api2", - "equivalent", - "foldhash", -] - [[package]] name = "hashbrown" version = "0.17.1" @@ -1561,7 +1550,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "cc4e190f5d26ca7051642629da2c52fc03bde85a03197c99408dcd291734c855" dependencies = [ "equivalent", - "hashbrown 0.17.1", + "hashbrown", ] [[package]] @@ -1840,11 +1829,11 @@ checksum = "f9f8bd3e56ce4dfc153cf470fffbfa98c7620958b312ca5c3a4b8d5181fd13c6" [[package]] name = "lru" -version = "0.16.4" +version = "0.18.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7f66e8d5d03f609abc3a39e6f08e4164ebf1447a732906d39eb9b99b7919ef39" +checksum = "ef9ac18847474e638e3702b76c65d4eb93428471a74778ef0f1be711717f89b5" dependencies = [ - "hashbrown 0.16.1", + "hashbrown", ] [[package]] @@ -2008,8 +1997,6 @@ dependencies = [ [[package]] name = "num-prime" version = "0.7.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6de1394909173a98f21f28406f9d82f0e11d87be4bf36473364f37a5bd100741" dependencies = [ "bitvec", "either", @@ -4286,7 +4273,7 @@ dependencies = [ "clap", "codspeed-divan-compat", "fluent", - "hashbrown 0.17.1", + "hashbrown", "memchr", "rustc-hash", "rustix", diff --git a/Cargo.toml b/Cargo.toml index 24b4c70..e7bd2b0 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -690,6 +690,12 @@ name = "uudoc" path = "src/bin/uudoc.rs" required-features = ["uudoc"] +# Security backport: num-prime 0.7.0 requires vulnerable lru 0.16.x. +# Use a local copy with lru >=0.18.5 until upstream updates its constraint. +# See https://rustsec.org/advisories/RUSTSEC-2026-0253.html and issue #1. +[patch.crates-io] +num-prime = { path = "vendor/num-prime" } + [profile.release] lto = "fat" panic = "abort" diff --git a/vendor/num-prime/COPYING b/vendor/num-prime/COPYING new file mode 100644 index 0000000..33cfaa3 --- /dev/null +++ b/vendor/num-prime/COPYING @@ -0,0 +1,5 @@ +Copyright (c) Jacob Zhong +Copyright (c) uutils developers + +Licensed under the Apache License, Version 2.0 or the MIT +license , at your option. diff --git a/vendor/num-prime/Cargo.toml b/vendor/num-prime/Cargo.toml new file mode 100644 index 0000000..f16d9eb --- /dev/null +++ b/vendor/num-prime/Cargo.toml @@ -0,0 +1,112 @@ +# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO +# +# When uploading crates to the registry Cargo will automatically +# "normalize" Cargo.toml files for maximal compatibility +# with all versions of Cargo and also rewrite `path` dependencies +# to registry (e.g., crates.io) dependencies. +# +# If you are reading this file be aware that the original Cargo.toml +# will likely look very different (and much more reasonable). +# See Cargo.toml.orig for the original contents. + +[package] +edition = "2021" +rust-version = "1.70" +name = "num-prime" +version = "0.7.0" +build = false +autolib = false +autobins = false +autoexamples = false +autotests = false +autobenches = false +description = """ +Generic and optimized primality test, factorization and various number theoretic functions with arbitrary precision based on `num`. +""" +documentation = "https://docs.rs/num-prime" +readme = "README.md" +keywords = [ + "bigint", + "mathematics", + "num", + "number-theory", + "primes", +] +categories = [ + "algorithms", + "cryptography", + "science", +] +license = "MIT OR Apache-2.0" +repository = "https://github.com/uutils/num-prime" + +[package.metadata.docs.rs] +all-features = true + +[features] +big-int = ["dep:num-bigint"] +big-table = [] +default = [ + "big-int", + "big-table", +] + +[lib] +name = "num_prime" +path = "src/lib.rs" + +[[example]] +name = "divisor_sigma" +path = "examples/divisor_sigma.rs" + +[[example]] +name = "find_lucky_primes" +path = "examples/find_lucky_primes.rs" + +[[example]] +name = "find_mersenne_primes" +path = "examples/find_mersenne_primes.rs" + +[[example]] +name = "prime_omega" +path = "examples/prime_omega.rs" + +[[example]] +name = "profile_factorization" +path = "examples/profile_factorization.rs" + +[[example]] +name = "test_comparison" +path = "examples/test_comparison.rs" + +[dependencies.bitvec] +version = "1.0.0" + +[dependencies.either] +version = "1.6.1" + +[dependencies.lru] +version = "0.18.5" + +[dependencies.num-bigint] +version = "0.4.6" +features = ["rand"] +optional = true + +[dependencies.num-integer] +version = "0.1.46" + +[dependencies.num-modular] +version = "0.6.2" +features = ["num-bigint"] + +[dependencies.num-traits] +version = "0.2.18" + +[dependencies.rand] +version = "0.8.6" + +[profile.release] +lto = "fat" +codegen-units = 1 +panic = "abort" diff --git a/vendor/num-prime/LICENSE-APACHE b/vendor/num-prime/LICENSE-APACHE new file mode 100644 index 0000000..d9a10c0 --- /dev/null +++ b/vendor/num-prime/LICENSE-APACHE @@ -0,0 +1,176 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS diff --git a/vendor/num-prime/LICENSE-MIT b/vendor/num-prime/LICENSE-MIT new file mode 100644 index 0000000..31aa793 --- /dev/null +++ b/vendor/num-prime/LICENSE-MIT @@ -0,0 +1,23 @@ +Permission is hereby granted, free of charge, to any +person obtaining a copy of this software and associated +documentation files (the "Software"), to deal in the +Software without restriction, including without +limitation the rights to use, copy, modify, merge, +publish, distribute, sublicense, and/or sell copies of +the Software, and to permit persons to whom the Software +is furnished to do so, subject to the following +conditions: + +The above copyright notice and this permission notice +shall be included in all copies or substantial portions +of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF +ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED +TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A +PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT +SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR +IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +DEALINGS IN THE SOFTWARE. diff --git a/vendor/num-prime/PATCH-NOTES.md b/vendor/num-prime/PATCH-NOTES.md new file mode 100644 index 0000000..82de841 --- /dev/null +++ b/vendor/num-prime/PATCH-NOTES.md @@ -0,0 +1,13 @@ +# Local security dependency override + +Maintainer of this integration: Hamdy Abou El Anein. + +This directory contains the source of `num-prime` **0.7.0**, redistributed with its original MIT and Apache-2.0 license files. The upstream source code has not been changed. + +## Why the local copy exists + +`num-prime 0.7.0` requires `lru = "0.16.3"`, which resolves to `lru 0.16.4`. This version is affected by [RUSTSEC-2026-0253](https://rustsec.org/advisories/RUSTSEC-2026-0253.html), a potential use-after-free in `LruCache::pop()` when a stored key's destructor panics. The first fixed release is `lru 0.18.2`. + +The only modification to the upstream crate is its `Cargo.toml` dependency on `lru`, raised to `0.18.5` to accept a patched release. The workspace-level `[patch.crates-io]` entry selects this copy, so the `factor` utility no longer resolves to vulnerable `lru 0.16.x`. + +This is a temporary workaround until an upstream `num-prime` release accepts a corrected `lru` version. Before removing it, update the dependency, regenerate `Cargo.lock`, and rerun `cargo tree -i lru`, `cargo check -p uu_factor --locked` and `cargo test -p uu_factor --locked`. diff --git a/vendor/num-prime/README.md b/vendor/num-prime/README.md new file mode 100644 index 0000000..1327411 --- /dev/null +++ b/vendor/num-prime/README.md @@ -0,0 +1,38 @@ +# num-prime + +[![Crates.io](https://img.shields.io/crates/v/num-prime.svg)](https://crates.io/crates/num-prime) +[![CodSpeed](https://img.shields.io/endpoint?url=https://codspeed.io/badge.json)](https://codspeed.io/uutils/num-prime?utm_source=badge) +[![Discord](https://img.shields.io/badge/discord-join-7289DA.svg?logo=discord&longCache=true&style=flat)](https://discord.gg/wQVJbvJ) +[![License](https://img.shields.io/crates/l/num-prime)](COPYRIGHT) +[![dependency status](https://deps.rs/repo/github/uutils/num-prime/status.svg)](https://deps.rs/repo/github/uutils/num-prime) + +[![CodeCov](https://codecov.io/gh/uutils/num-prime/branch/main/graph/badge.svg)](https://codecov.io/gh/uutils/num-prime) + +This crate provides utilities for prime number related functionalities: + +- Primality testing + - Deterministic primality check of `u64` integers (using a very fast hashing algorithm) + - Fermat probable prime test + - Miller-rabin probable prime test + - (strong/extra strong) Lucas probable prime test + - Baillie-PSW test + - Sophie Germain safe prime test +- Primes generation and indexing + - A naive implementation of the sieve of Eratosthenes + - Unified API to support other prime generation backends + - Generate random (safe) primes + - Find previous/next prime +- Integer factorization + - Trial division + - Pollard's rho algorithm + - Shanks's square forms factorization (SQUFOF) + - Fast factorization of `u64` and `u128` integers + - Factorization beyond `u128`, with Pollard's rho over Montgomery arithmetic +- Number theoretic functions + - Prime Pi function (number of primes under limit), its estimation and its bounds + - Nth prime, its estimation and its bounds + - Moebius function + - Divisor Sigma function *([in examples](./examples/divisor_sigma.rs))* + - Prime Omega function *([in examples](./examples/prime_omega.rs))* + +It's based on the `num` crates and most functions are decently optimized with pre-computed tables (see **[benchmark results here](./PERFORMANCE.md)**). diff --git a/vendor/num-prime/src/buffer.rs b/vendor/num-prime/src/buffer.rs new file mode 100644 index 0000000..080b448 --- /dev/null +++ b/vendor/num-prime/src/buffer.rs @@ -0,0 +1,929 @@ +//! Implementations and extensions for [`PrimeBuffer`], which represents a container of primes +//! +//! In `num-prime`, there is no global instance to store primes, the user has to generate +//! and store the primes themselves. The trait [`PrimeBuffer`] defines a unified interface +//! for a prime number container. Some methods that can take advantage of pre-generated +//! primes will be implemented in the [`PrimeBufferExt`] trait. +//! +//! We also provide [`NaiveBuffer`] as a simple implementation of [`PrimeBuffer`] without any +//! external dependencies. The performance of the [`NaiveBuffer`] will not be extremely optimized, +//! but it will be efficient enough for most applications. +//! + +use crate::factor::{pollard_rho, trial_division}; +use crate::nt_funcs::{ + factorize128, is_prime64, next_prime, nth_prime_bounds, nth_prime_est, prev_prime, +}; +use crate::primality::{PrimalityBase, PrimalityRefBase}; +use crate::splitmix64::SplitMix64; +use crate::tables::{SMALL_PRIMES, SMALL_PRIMES_NEXT}; +use crate::traits::{ + FactorizationConfig, Primality, PrimalityTestConfig, PrimalityUtils, PrimeBuffer, +}; +use bitvec::{bitvec, prelude::Msb0}; +use lru::LruCache; +use num_integer::Roots; +use std::collections::BTreeMap; +use std::num::NonZeroUsize; + +/// Extension functions that can utilize pre-generated primes +pub trait PrimeBufferExt: for<'a> PrimeBuffer<'a> { + /// Test if an integer is a prime. + /// + /// For targets smaller than 2^64, the deterministic [`is_prime64`] will be used, otherwise + /// the primality test algorithms can be specified by the `config` argument. + /// + /// The primality test can be either deterministic or probabilistic for large integers depending on the `config`. + /// The return value is represented by the enum [Primality], which tells whether the primality test is deterministic + /// or probabilistic. + fn is_prime( + &self, + target: &T, + config: Option, + ) -> Primality + where + for<'r> &'r T: PrimalityRefBase, + { + // shortcuts + if target.is_even() { + return if target == &T::from_u8(2u8).unwrap() { + Primality::Yes + } else { + Primality::No + }; + } + + // do deterministic test if target is under 2^64 + if let Some(x) = target.to_u64() { + return match is_prime64(x) { + true => Primality::Yes, + false => Primality::No, + }; + } + + let config = config.unwrap_or_default(); + let mut probability = 1.; + + // miller-rabin test + let mut witness_list: Vec = + Vec::with_capacity(config.sprp_trials + config.sprp_random_trials); + if config.sprp_trials > 0 { + witness_list.extend(self.iter().take(config.sprp_trials)); + probability *= 1. - 0.25f32.powi(config.sprp_trials as i32); + } + if config.sprp_random_trials > 0 { + for _ in 0..config.sprp_random_trials { + // we have ensured target is larger than 2^64 + let mut w: u64 = rand::random(); + while witness_list.iter().any(|x| x == &w) { + w = rand::random(); + } + witness_list.push(w); + } + probability *= 1. - 0.25f32.powi(config.sprp_random_trials as i32); + } + if !witness_list + .into_iter() + .all(|x| target.is_sprp(T::from_u64(x).unwrap())) + { + return Primality::No; + } + + // lucas probable prime test + if config.slprp_test { + probability *= 1. - 4f32 / 15f32; + if !target.is_slprp(None, None) { + return Primality::No; + } + } + if config.eslprp_test { + probability *= 1. - 4f32 / 15f32; + if !target.is_eslprp(None) { + return Primality::No; + } + } + + Primality::Probable(probability) + } + + /// Factorize an integer. + /// + /// For targets smaller than 2^64, the efficient [`crate::nt_funcs::factorize64`] will be used, otherwise + /// the primality test and factorization algorithms can be specified by the `config` argument. + /// + /// The factorization result consists of two parts. The first is a map from prime factors to their exponents. + /// If the factorization failed, the second part will be the remaining cofactors that are not factored, otherwise None + /// is returned for the second part. It's ensured that the product of prime factors (and remaining cofactors if exist) + /// is equal to the original target. + fn factors( + &self, + target: T, + config: Option, + ) -> (BTreeMap, Option>) + where + for<'r> &'r T: PrimalityRefBase, + { + // shortcut if the target is in u128 range + if let Some(x) = target.to_u128() { + let factors = factorize128(x) + .into_iter() + .map(|(k, v)| (T::from_u128(k).unwrap(), v)) + .collect(); + return (factors, None); + } + let config = config.unwrap_or_default(); + + // test the existing primes + let (result, factored) = trial_division(self.iter().copied(), target, config.td_limit); + let mut result: BTreeMap = result + .into_iter() + .map(|(k, v)| (T::from_u64(k).unwrap(), v)) + .collect(); + + // TODO: check is_perfect_power before other methods + + // find factors by dividing + let mut failed = Vec::new(); + let mut config = config; + config.td_limit = Some(0); // disable trial division when finding divisor + match factored { + Ok(res) => { + if !res.is_one() { + result.insert(res, 1); + } + } + Err(res) => { + let mut todo = vec![res]; + while let Some(target) = todo.pop() { + if self + .is_prime(&target, Some(config.primality_config)) + .probably() + { + *result.entry(target).or_insert(0) += 1; + } else if let Some(cofactors) = split_composite(&target) { + todo.extend(cofactors); + } else if let Some(divisor) = { + // Give every cofactor its own budget: a shared one is + // exhausted by the first splits and every remaining + // composite is then reported as a failure. + let mut config = config; + self.divisor(&target, &mut config) + } { + todo.push(divisor.clone()); + todo.push(target / divisor); + } else { + failed.push(target); + } + } + } + }; + + if failed.is_empty() { + (result, None) + } else { + (result, Some(failed)) + } + } + + /// Factorize an integer until all prime factors are found. + /// + /// This function will try to call [`PrimeBufferExt::factors`] function repeatedly until the target + /// is fully factorized. + fn factorize(&self, target: T) -> BTreeMap + where + for<'r> &'r T: PrimalityRefBase, + { + // TODO: prevent overhead of repeat trial division + loop { + let (result, remainder) = self.factors(target.clone(), None); + if remainder.is_none() { + break result; + } + } + } + + /// Return a proper divisor of target (randomly), even works for very large numbers. + /// Return `None` if no factor is found. + /// + /// Note: this method will not do a primality check + fn divisor(&self, target: &T, config: &mut FactorizationConfig) -> Option + where + for<'r> &'r T: PrimalityRefBase, + { + if matches!(config.td_limit, Some(0)) { + // try to get a factor by trial division + let tsqrt: T = Roots::sqrt(target) + T::one(); + let limit = if let Some(l) = config.td_limit { + tsqrt.clone().min(T::from_u64(l).unwrap()) + } else { + tsqrt.clone() + }; + + for p in self.iter().map(|p| T::from_u64(*p).unwrap()) { + if p > tsqrt { + return None; // the number is a prime + } + if p > limit { + break; + } + if target.is_multiple_of(&p) { + return Some(p); + } + } + } + + // try to get a factor using pollard_rho with 4x4 trials + let below64 = target.to_u64().is_some(); + let mut rng = SplitMix64::new( + target + .to_u64() + .unwrap_or_else(|| (target % T::from_u64(u64::MAX).unwrap()).to_u64().unwrap()), + ); + while config.rho_trials > 0 { + let (start, offset) = if below64 { + ( + T::from_u8(rng.next_u64() as u8).unwrap() % target, + T::from_u8(rng.next_u64() as u8).unwrap() % target, + ) + } else { + ( + T::from_u64(rng.next_u64()).unwrap() % target, + T::from_u64(rng.next_u64()).unwrap() % target, + ) + }; + config.rho_trials -= 1; + // TODO: change to a reasonable pollard rho limit + // TODO: add other factorization methods + if let (Some(p), _) = pollard_rho(target, start, offset, 1_048_576) { + return Some(p); + } + } + + None + } +} + +/// Split a composite cofactor with the specialized paths. +/// +/// Within `u128` that is [`factorize128`], which is far better tuned than the +/// generic code. Beyond it the generic modular arithmetic reduces by division +/// on every step, so [`crate::montgomery`] keeps the modulus in Montgomery +/// form instead; it also peels off perfect powers, which Pollard's rho cannot +/// split. Returns `None` when neither applies. +fn split_composite(target: &T) -> Option> +where + for<'r> &'r T: PrimalityRefBase, +{ + if let Some(narrow) = target.to_u128() { + let mut factors = Vec::new(); + for (factor, exp) in crate::nt_funcs::factorize128(narrow) { + factors.extend(core::iter::repeat(T::from_u128(factor).unwrap()).take(exp)); + } + return Some(factors); + } + split_wide(target) +} + +#[cfg(feature = "big-int")] +fn split_wide(target: &T) -> Option> +where + for<'r> &'r T: PrimalityRefBase, +{ + use crate::montgomery::{divisor, from_biguint, to_biguint, Split}; + + let wide = to_biguint(target); + Some(match divisor(&wide) { + Split::Divisor(d) => { + let d: T = from_biguint(&d); + vec![target.clone() / d.clone(), d] + } + Split::Power(root, exp) => { + let root: T = from_biguint(&root); + vec![root; exp as usize] + } + }) +} + +#[cfg(not(feature = "big-int"))] +fn split_wide(_target: &T) -> Option> +where + for<'r> &'r T: PrimalityRefBase, +{ + None +} + +impl PrimeBufferExt for T where for<'a> T: PrimeBuffer<'a> {} + +/// `NaiveBuffer` implements a very simple Sieve of Eratosthenes +pub struct NaiveBuffer { + list: Vec, // list of found prime numbers + next: u64, // all primes smaller than this value has to be in the prime list, should be an odd number +} + +impl Default for NaiveBuffer { + fn default() -> Self { + Self::new() + } +} + +impl NaiveBuffer { + #[inline] + #[must_use] + pub fn new() -> Self { + let list = SMALL_PRIMES.iter().map(|&p| u64::from(p)).collect(); + NaiveBuffer { + list, + next: SMALL_PRIMES_NEXT, + } + } +} + +impl<'a> PrimeBuffer<'a> for NaiveBuffer { + type PrimeIter = std::slice::Iter<'a, u64>; + + fn contains(&self, num: u64) -> bool { + self.list.binary_search(&num).is_ok() + } + + fn clear(&mut self) { + self.list.truncate(16); + self.list.shrink_to_fit(); + self.next = 55; // 16-th prime is 53 + } + + fn iter(&'a self) -> Self::PrimeIter { + self.list.iter() + } + + fn bound(&self) -> u64 { + *self.list.last().unwrap() + } + + fn reserve(&mut self, limit: u64) { + let sieve_limit = (limit | 1) + 2; // make sure sieving limit is odd and larger than limit + let current = self.next; // prevent borrowing self + debug_assert!(current % 2 == 1); + if sieve_limit < current { + return; + } + + // create sieve and filter with existing primes + let mut sieve = bitvec![usize, Msb0; 0; ((sieve_limit - current) / 2) as usize]; + for p in self.list.iter().skip(1) { + // skip pre-filtered 2 + let start = if p * p < current { + p * ((current / p) | 1) // start from an odd factor + } else { + p * p + }; + for multi in (start..sieve_limit).step_by(2 * (*p as usize)) { + if multi >= current { + sieve.set(((multi - current) / 2) as usize, true); + } + } + } + + // sieve with new primes + for p in (current..Roots::sqrt(&sieve_limit) + 1).step_by(2) { + for multi in (p * p..sieve_limit).step_by(2 * (p as usize)) { + if multi >= current { + sieve.set(((multi - current) / 2) as usize, true); + } + } + } + + // collect the sieve + self.list + .extend(sieve.iter_zeros().map(|x| (x as u64) * 2 + current)); + self.next = sieve_limit; + } +} + +impl NaiveBuffer { + // FIXME: These functions could be implemented in the trait, but only after + // RFC 2071 and https://github.com/cramertj/impl-trait-goals/issues/3 + + /// Calculate the primorial function + pub fn primorial(&mut self, n: usize) -> T { + self.nprimes(n).map(|&p| T::from_u64(p).unwrap()).product() + } + + /// Returns all primes ≤ `limit`. The primes are sorted. + // TODO: let primes return &[u64] instead of iterator, and create a separate iterator + // for endless prime iter. This can be a method in this trait, or standalone function, + // or implement as IntoIter. We can try to implement PrimeBuffer on primal first and see + // if it's reasonable to unifiy + pub fn primes(&mut self, limit: u64) -> std::iter::Take<>::PrimeIter> { + self.reserve(limit); + let position = match self.list.binary_search(&limit) { + Ok(p) => p + 1, + Err(p) => p, + }; // into_ok_or_err() + self.list.iter().take(position) + } + + /// Returns all primes ≤ `limit` and takes ownership. The primes are sorted. + #[must_use] + pub fn into_primes(mut self, limit: u64) -> std::vec::IntoIter { + self.reserve(limit); + let position = match self.list.binary_search(&limit) { + Ok(p) => p + 1, + Err(p) => p, + }; // into_ok_or_err() + self.list.truncate(position); + self.list.into_iter() + } + + /// Returns primes of certain amount counting from 2. The primes are sorted. + pub fn nprimes( + &mut self, + count: usize, + ) -> std::iter::Take<>::PrimeIter> { + let (_, bound) = nth_prime_bounds(&(count as u64)) + .expect("Estimated size of the largest prime will be larger than u64 limit"); + self.reserve(bound); + debug_assert!(self.list.len() >= count); + self.list.iter().take(count) + } + + /// Returns primes of certain amount counting from 2 and takes ownership. The primes are sorted. + #[must_use] + pub fn into_nprimes(mut self, count: usize) -> std::vec::IntoIter { + let (_, bound) = nth_prime_bounds(&(count as u64)) + .expect("Estimated size of the largest prime will be larger than u64 limit"); + self.reserve(bound); + debug_assert!(self.list.len() >= count); + self.list.truncate(count); + self.list.into_iter() + } + + /// Get the n-th prime (n counts from 1). + /// + /// Theoretically the result can be larger than 2^64, but it will takes forever to + /// calculate that so we just return `u64` instead of `Option` here. + pub fn nth_prime(&mut self, n: u64) -> u64 { + if n < self.list.len() as u64 { + return self.list[n as usize - 1]; + } + + // Directly sieve if the limit is small + const THRESHOLD_NTH_PRIME_SIEVE: u64 = 4096; + if n <= THRESHOLD_NTH_PRIME_SIEVE { + return *self.nprimes(n as usize).next_back().unwrap(); + } + + // Check primes starting from estimation + let mut x = prev_prime(&nth_prime_est(&n).unwrap(), None).unwrap(); + let mut pi = self.prime_pi(x); + + while pi > n { + x = prev_prime(&x, None).unwrap(); + pi -= 1; + } + while pi < n { + x = next_prime(&x, None).unwrap(); + pi += 1; + } + x + } + + /// Legendre's phi function, used as a helper function for [`Self::prime_pi`] + pub fn prime_phi(&mut self, x: u64, a: usize, cache: &mut LruCache<(u64, usize), u64>) -> u64 { + if a == 1 { + // TODO(MSRV>=1.73): feature(int_roundings1): use div_ceil + return crate::util::div_ceil_u64(x, 2); + } + if let Some(v) = cache.get(&(x, a)) { + return *v; + } + let t1 = self.prime_phi(x, a - 1, cache); + let pa = self.nth_prime(a as u64); + let t2 = self.prime_phi(x / pa, a - 1, cache); + let t = t1 - t2; + cache.put((x, a), t); + t + } + + /// Calculate the prime π function, i.e. number of primes ≤ `limit`. + /// + /// Meissel-Lehmer method will be used if the input `limit` is large enough. + pub fn prime_pi(&mut self, limit: u64) -> u64 { + // Directly sieve if the limit is small + const THRESHOLD_PRIME_PI_SIEVE: u64 = 38873; // 4096th prime + if &limit <= self.list.last().unwrap() || limit <= THRESHOLD_PRIME_PI_SIEVE { + self.reserve(limit); + + return match self.list.binary_search(&limit) { + Ok(pos) => (pos + 1) as u64, + Err(pos) => pos as u64, + }; + } + + // Then use Meissel-Lehmer method. + let b = limit.sqrt(); + let a = b.sqrt(); + let c = limit.cbrt(); + self.reserve(b); + + let a = self.prime_pi(a); + let b = self.prime_pi(b); + let c = self.prime_pi(c); + + let cache_cap = NonZeroUsize::new(a as usize).unwrap(); // a > 0 because limit > THRESHOLD_PRIME_PI_SIEVE + let mut phi_cache = LruCache::new(cache_cap); + let mut sum = + self.prime_phi(limit, a as usize, &mut phi_cache) + (b + a - 2) * (b - a + 1) / 2; + for i in (a + 1)..=b { + let w = limit / self.nth_prime(i); + sum -= self.prime_pi(w); + if i <= c { + let l = self.prime_pi(w.sqrt()); + sum += (l * (l - 1) - i * (i - 3)) / 2 - 1; + for j in i..=l { + let pj = self.nth_prime(j); + sum -= self.prime_pi(w / pj); + } + } + } + sum + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::mint::SmallMint; + #[cfg(feature = "big-int")] + use core::str::FromStr; + #[cfg(feature = "big-int")] + use num_bigint::BigUint; + use rand::random; + + /// A 512-bit product of thirteen primes near 2^39. Every rho split used to + /// draw on one shared budget of four trials, so everything past the fourth + /// split came back as an unfactored remainder. + #[cfg(feature = "big-int")] + const THIRTEEN_PRIMES: &str = "256192672085272469290287843204387360975152374284235599731951768269391636066386517575760286247162035537155995319918598846421204855240141082924971355328149"; + + #[cfg(feature = "big-int")] + #[test] + fn factors_many_similar_primes_completely() { + let target = BigUint::from_str(THIRTEEN_PRIMES).unwrap(); + let buffer = NaiveBuffer::new(); + let (factors, remainder) = buffer.factors(target.clone(), None); + assert_eq!(remainder, None); + assert_eq!(factors.values().sum::(), 13); + let product = factors + .iter() + .fold(BigUint::from(1u8), |acc, (f, e)| acc * f.pow(*e as u32)); + assert_eq!(product, target); + for factor in factors.keys() { + assert!( + buffer.is_prime(factor, None).probably(), + "{} is not prime", + factor + ); + } + } + + #[cfg(feature = "big-int")] + #[test] + fn factors_a_wide_prime_power() { + // 34359738421^7, which Pollard's rho on its own cannot split + let target = BigUint::from_str("34359738421").unwrap().pow(7u32); + let (factors, remainder): (BTreeMap, _) = + NaiveBuffer::new().factors(target, None); + assert_eq!(remainder, None); + assert_eq!(factors.len(), 1); + assert_eq!(factors[&BigUint::from_str("34359738421").unwrap()], 7); + } + + #[cfg(feature = "big-int")] + #[test] + fn factors_a_wide_number_with_small_factors() { + // 2^70 * 3^5 * 5 * 340282366920938463463374607431768211507 + let target = + BigUint::from_str("488107430943668296195870985548628140589274519139277715139461120") + .unwrap(); + let (factors, remainder): (BTreeMap, _) = + NaiveBuffer::new().factors(target, None); + assert_eq!(remainder, None); + assert_eq!(factors[&BigUint::from(2u8)], 70); + assert_eq!(factors[&BigUint::from(3u8)], 5); + assert_eq!(factors[&BigUint::from(5u8)], 1); + assert_eq!( + factors[&BigUint::from_str("340282366920938463463374607431768211507").unwrap()], + 1 + ); + } + + #[test] + fn prime_generation_test() { + const PRIME50: [u64; 15] = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]; + const PRIME300: [u64; 62] = [ + 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, + 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, + 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, + 277, 281, 283, 293, + ]; + + let mut pb = NaiveBuffer::new(); + assert_eq!(pb.primes(50).copied().collect::>(), PRIME50); + assert_eq!(pb.primes(300).copied().collect::>(), PRIME300); + + // test when limit itself is a prime + pb.clear(); + assert_eq!(pb.primes(293).copied().collect::>(), PRIME300); + pb = NaiveBuffer::new(); + assert_eq!(*pb.primes(257).next_back().unwrap(), 257); // boundary of small table + pb = NaiveBuffer::new(); + assert_eq!(*pb.primes(8167).next_back().unwrap(), 8167); // boundary of large table + } + + #[test] + fn nth_prime_test() { + let mut pb = NaiveBuffer::new(); + assert_eq!(pb.nth_prime(10000), 104_729); + assert_eq!(pb.nth_prime(20000), 224_737); + assert_eq!(pb.nth_prime(10000), 104_729); // use existing primes + + // Riemann zeta based, test on OEIS:A006988 + assert_eq!(pb.nth_prime(10u64.pow(4)), 104_729); + assert_eq!(pb.nth_prime(10u64.pow(5)), 1_299_709); + assert_eq!(pb.nth_prime(10u64.pow(6)), 15_485_863); + assert_eq!(pb.nth_prime(10u64.pow(7)), 179_424_673); + } + + #[test] + fn prime_pi_test() { + let mut pb = NaiveBuffer::new(); + assert_eq!(pb.prime_pi(8161), 1024); // 8161 is the 1024th prime + assert_eq!(pb.prime_pi(10000), 1229); + assert_eq!(pb.prime_pi(20000), 2262); + assert_eq!(pb.prime_pi(38873), 4096); + + pb.clear(); // sieving from scratch + assert_eq!(pb.prime_pi(8161), 1024); + assert_eq!(pb.prime_pi(10000), 1229); + assert_eq!(pb.prime_pi(20000), 2262); + assert_eq!(pb.prime_pi(10000), 1229); // use existing primes + + // Meissel–Lehmer algorithm, test on OEIS:A006880 + assert_eq!(pb.prime_pi(10u64.pow(5)), 9592); + assert_eq!(pb.prime_pi(10u64.pow(6)), 78498); + assert_eq!(pb.prime_pi(10u64.pow(7)), 664_579); + assert_eq!(pb.prime_pi(10u64.pow(8)), 5_761_455); + } + + #[test] + fn is_prime_test() { + // test for is_prime + let pb = NaiveBuffer::new(); + + // some mersenne numbers + assert_eq!(pb.is_prime(&(2u32.pow(19) - 1), None), Primality::Yes); + assert_eq!(pb.is_prime(&(2u32.pow(23) - 1), None), Primality::No); + assert!(matches!( + pb.is_prime(&(2u128.pow(89) - 1), None), + Primality::Probable(_) + )); + assert!(matches!( + pb.is_prime(&SmallMint::from(2u128.pow(89) - 1), None), + Primality::Probable(_) + )); + + // test against small prime assertion + for _ in 0..100 { + let target = random::(); + assert_eq!( + !is_prime64(target), + matches!( + pb.is_prime(&target, Some(PrimalityTestConfig::bpsw())), + Primality::No + ) + ); + } + + // test large numbers + const P: u128 = 18_699_199_384_836_356_663; // https://golang.org/issue/638 + assert!(matches!(pb.is_prime(&P, None), Primality::Probable(_))); + assert!(matches!( + pb.is_prime(&P, Some(PrimalityTestConfig::bpsw())), + Primality::Probable(_) + )); + assert!(matches!( + pb.is_prime(&SmallMint::from(P), None), + Primality::Probable(_) + )); + assert!(matches!( + pb.is_prime(&SmallMint::from(P), Some(PrimalityTestConfig::bpsw())), + Primality::Probable(_) + )); + + const P2: u128 = 2_019_922_777_445_599_503_530_083; + assert!(matches!(pb.is_prime(&P2, None), Primality::Probable(_))); + assert!(matches!( + pb.is_prime(&P2, Some(PrimalityTestConfig::bpsw())), + Primality::Probable(_) + )); + assert!(matches!( + pb.is_prime(&SmallMint::from(P2), None), + Primality::Probable(_) + )); + assert!(matches!( + pb.is_prime(&SmallMint::from(P2), Some(PrimalityTestConfig::bpsw())), + Primality::Probable(_) + )); + + #[cfg(feature = "big-int")] + { + let large_primes = [ + "98920366548084643601728869055592650835572950932266967461790948584315647051443", + "94560208308847015747498523884063394671606671904944666360068158221458669711639", + + // http://primes.utm.edu/lists/small/small3.html + "449417999055441493994709297093108513015373787049558499205492347871729927573118262811508386655998299074566974373711472560655026288668094291699357843464363003144674940345912431129144354948751003607115263071543163", + "230975859993204150666423538988557839555560243929065415434980904258310530753006723857139742334640122533598517597674807096648905501653461687601339782814316124971547968912893214002992086353183070342498989426570593", + "5521712099665906221540423207019333379125265462121169655563495403888449493493629943498064604536961775110765377745550377067893607246020694972959780839151452457728855382113555867743022746090187341871655890805971735385789993", + "203956878356401977405765866929034577280193993314348263094772646453283062722701277632936616063144088173312372882677123879538709400158306567338328279154499698366071906766440037074217117805690872792848149112022286332144876183376326512083574821647933992961249917319836219304274280243803104015000563790123", + // ECC primes: http://tools.ietf.org/html/draft-ladd-safecurves-02 + "3618502788666131106986593281521497120414687020801267626233049500247285301239", // Curve1174: 2^251-9 + "57896044618658097711785492504343953926634992332820282019728792003956564819949", // Curve25519: 2^255-19 + "9850501549098619803069760025035903451269934817616361666987073351061430442874302652853566563721228910201656997576599", // E-382: 2^382-105 + "42307582002575910332922579714097346549017899709713998034217522897561970639123926132812109468141778230245837569601494931472367", // Curve41417: 2^414-17 + "6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151", // E-521: 2^521-1 + + // https://github.com/AtropineTears/num-primes/issues/1#issuecomment-934629597 + "169511182982703321453314585423962898651587669459838234386506572286328885534468792292646838949809616446341407457141008401355628947670484184607678853094537849610289912805960069455687743151708433319901176932959509872662610091644590437761688516626993416011399330087939042347256922771590903190536793274742859624657" + ]; + for pstr in large_primes { + assert!( + pb.is_prime(&BigUint::from_str(pstr).unwrap(), None) + .probably(), + "false negative prime {}", + pstr + ) + } + + let large_composites = [ + "21284175091214687912771199898307297748211672914763848041968395774954376176754", + "6084766654921918907427900243509372380954290099172559290432744450051395395951", + "84594350493221918389213352992032324280367711247940675652888030554255915464401", + "82793403787388584738507275144194252681", + + // Arnault, "Rabin-Miller Primality Test: Composite Numbers Which Pass It", + // Mathematics of Computation, 64(209) (January 1995), pp. 335-361. + "1195068768795265792518361315725116351898245581", // strong pseudoprime to prime bases 2 through 29 + // strong pseudoprime to all prime bases up to 200 + "8038374574536394912570796143419421081388376882875581458374889175222974273765333652186502336163960045457915042023603208766569966760987284043965408232928738791850869166857328267761771029389697739470167082304286871099974399765441448453411558724506334092790222752962294149842306881685404326457534018329786111298960644845216191652872597534901", + ]; + for cstr in large_composites { + assert!( + !pb.is_prime( + &BigUint::from_str(cstr).unwrap(), + Some(PrimalityTestConfig::bpsw()) + ) + .probably(), + "false positive prime {}", + cstr + ) + } + } + } + + #[test] + fn pb_factors_test() { + #[cfg(feature = "big-int")] + { + let pb = NaiveBuffer::new(); + let m131 = BigUint::from(2u8).pow(131) - 1u8; // m131/263 is a large prime + let (fac, r) = pb.factors(m131, None); + assert!(fac.len() == 2 && r.is_none()); + } + } + + // --- NaiveBuffer::clear() + re-reserve --- + #[test] + fn test_clear_and_re_reserve() { + let mut pb = NaiveBuffer::new(); + pb.reserve(100); + assert!(pb.bound() >= 100); + assert!(pb.contains(97)); + pb.clear(); + // After clear, only 16 primes remain (up to 53) + assert_eq!(pb.bound(), 53); + assert!(!pb.contains(97)); // 97 should be gone + // Re-reserve brings primes back + pb.reserve(100); + assert!(pb.bound() >= 100); + assert!(pb.contains(97)); + } + + // --- into_primes() --- + #[test] + fn test_into_primes() { + let pb = NaiveBuffer::new(); + let primes: Vec = pb.into_primes(20).collect(); + assert_eq!(primes, vec![2, 3, 5, 7, 11, 13, 17, 19]); + } + + #[test] + fn test_into_primes_exact_boundary() { + let pb = NaiveBuffer::new(); + // 23 is a prime, should be included + let primes: Vec = pb.into_primes(23).collect(); + assert_eq!(*primes.last().unwrap(), 23); + } + + // --- into_nprimes() --- + #[test] + fn test_into_nprimes() { + let pb = NaiveBuffer::new(); + let primes: Vec = pb.into_nprimes(10).collect(); + assert_eq!(primes.len(), 10); + assert_eq!(primes[0], 2); + assert_eq!(primes[9], 29); + } + + // --- primorial() --- + #[test] + fn test_primorial() { + let mut pb = NaiveBuffer::new(); + // primorial(4) = 2 * 3 * 5 * 7 = 210 + let result: u64 = pb.primorial(4); + assert_eq!(result, 210); + // primorial(1) = 2 + let result: u64 = pb.primorial(1); + assert_eq!(result, 2); + } + + // --- is_prime with eslprp config --- + #[test] + fn test_is_prime_eslprp_config() { + let pb = NaiveBuffer::new(); + let config = PrimalityTestConfig { + sprp_trials: 1, + sprp_random_trials: 0, + slprp_test: false, + eslprp_test: true, + }; + let p: u128 = 18_699_199_384_836_356_663; + assert!(pb.is_prime(&p, Some(config)).probably()); + } + + // --- is_prime with strict config --- + #[test] + fn test_is_prime_strict_config() { + let pb = NaiveBuffer::new(); + let p: u128 = 2_019_922_777_445_599_503_530_083; + assert!(pb + .is_prime(&p, Some(PrimalityTestConfig::strict())) + .probably()); + + // composite should fail + let c: u128 = 2_019_922_777_445_599_503_530_083 * 3; + assert!(!pb + .is_prime(&c, Some(PrimalityTestConfig::strict())) + .probably()); + } + + // --- factors() for u128 composites --- + #[test] + fn test_factors_u128() { + let pb = NaiveBuffer::new(); + // Factor a u128 composite: 2^3 * 3^2 * 5 = 360 + let (factors, remainder) = pb.factors(360u128, None); + assert!(remainder.is_none()); + assert_eq!(factors[&2], 3); + assert_eq!(factors[&3], 2); + assert_eq!(factors[&5], 1); + } + + #[test] + fn test_factors_u128_large() { + let pb = NaiveBuffer::new(); + // 2^64 + 1 = 274177 * 67280421310721 + let n: u128 = (1u128 << 64) + 1; + let (factors, remainder) = pb.factors(n, None); + assert!(remainder.is_none()); + assert!(factors.contains_key(&274177u128)); + } + + // --- is_prime on even numbers --- + #[test] + fn test_is_prime_even() { + let pb = NaiveBuffer::new(); + assert_eq!(pb.is_prime(&2u128, None), Primality::Yes); + assert_eq!(pb.is_prime(&4u128, None), Primality::No); + } + + // --- factors with strict config --- + #[test] + fn test_factors_with_strict_config() { + let pb = NaiveBuffer::new(); + let (factors, remainder) = pb.factors(100u64, Some(FactorizationConfig::strict())); + assert!(remainder.is_none()); + assert_eq!(factors[&2], 2); + assert_eq!(factors[&5], 2); + } +} diff --git a/vendor/num-prime/src/factor.rs b/vendor/num-prime/src/factor.rs new file mode 100644 index 0000000..0fee3bb --- /dev/null +++ b/vendor/num-prime/src/factor.rs @@ -0,0 +1,582 @@ +//! Implementations for various factorization algorithms. +//! +//! Note general prime number field sieve is not planned to be implemented, since it's too complex +//! +//! See +//! for a detailed comparison between different factorization algorithms + +// XXX: make the factorization method resumable? Maybe let all of them returns a Future + +use crate::traits::ExactRoots; +use num_integer::{Integer, Roots}; +use num_modular::{ModularCoreOps, ModularUnaryOps}; +use num_traits::{CheckedAdd, CheckedMul, FromPrimitive, NumRef, RefNum}; +use std::collections::BTreeMap; + +/// Find factors by trial division, returns a tuple of the found factors and the residual. +/// +/// The target is guaranteed fully factored only if bound * bound > target, where bound = max(primes). +/// The parameter limit additionally sets the maximum of primes to be tried. +/// The residual will be Ok(1) or Ok(p) if fully factored. +/// +/// # Examples +/// +/// ``` +/// use num_prime::factor::trial_division; +/// +/// let primes = vec![2, 3, 5, 7, 11, 13]; +/// let (factors, residual) = trial_division(primes.into_iter(), 60u64, None); +/// assert_eq!(factors[&2], 2); +/// assert_eq!(factors[&3], 1); +/// assert_eq!(factors[&5], 1); +/// assert!(residual.is_ok()); +/// ``` +/// +/// TODO: implement fast check for small primes with `BigInts` in the precomputed table, and skip them in this function +pub fn trial_division< + I: Iterator, + T: Integer + Clone + Roots + NumRef + FromPrimitive, +>( + primes: I, + target: T, + limit: Option, +) -> (BTreeMap, Result) +where + for<'r> &'r T: RefNum, +{ + let tsqrt: T = Roots::sqrt(&target) + T::one(); + let limit = if let Some(l) = limit { + tsqrt.clone().min(T::from_u64(l).unwrap()) + } else { + tsqrt.clone() + }; + + let mut residual = target; + let mut result = BTreeMap::new(); + let mut factored = false; + for (p, pt) in primes.map(|p| (p, T::from_u64(p).unwrap())) { + if pt > tsqrt { + factored = true; + } + if pt > limit { + break; + } + + while residual.is_multiple_of(&pt) { + residual = residual / &pt; + *result.entry(p).or_insert(0) += 1; + } + if residual.is_one() { + factored = true; + break; + } + } + + if factored { + (result, Ok(residual)) + } else { + (result, Err(residual)) + } +} + +/// Find factors using Pollard's rho algorithm with Brent's loop detection algorithm +/// +/// The returned values are the factor and the count of passed iterations. +/// +/// # Examples +/// +/// ``` +/// use num_prime::factor::pollard_rho; +/// +/// let (factor, _iterations) = pollard_rho(&8051u16, 2, 1, 100); +/// assert_eq!(factor, Some(97)); // 8051 = 83 × 97 +/// ``` +pub fn pollard_rho< + T: Integer + + FromPrimitive + + NumRef + + Clone + + for<'r> ModularCoreOps<&'r T, &'r T, Output = T> + + for<'r> ModularUnaryOps<&'r T, Output = T>, +>( + target: &T, + start: T, + offset: T, + max_iter: usize, +) -> (Option, usize) +where + for<'r> &'r T: RefNum, +{ + let mut a = start.clone(); + let mut b = start.clone(); + let mut z = T::one() % target; // accumulator for gcd + + // using Brent's loop detection, i = tortoise, j = hare + let (mut i, mut j) = (0usize, 1usize); + + // backtracing states + let mut s = start; + let mut backtrace = false; + + while i < max_iter { + i += 1; + // Not `a.sqm(target)`: for arbitrary-precision types that is a modular + // exponentiation, which costs far more than a single multiplication. + a = a.clone().mulm(&a, target).addm(&offset, target); + if a == b { + return (None, i); + } + + // gcd(n, -t) = gcd(n, t), so no abs-diff: ordering Montgomery forms + // would need a residue() per walker, and `subm` cannot underflow. + let diff = a.clone().subm(&b, target); + z = z.mulm(&diff, target); + if z.is_zero() { + // the factor is missed by a combined GCD, do backtracing + if backtrace { + // ultimately failed + return (None, i); + } else { + backtrace = true; + a = std::mem::replace(&mut s, T::one()); // s is discarded + z = T::one() % target; // clear gcd + continue; + } + } + + // here we check gcd every 2^k steps or 128 steps + // larger batch size leads to large overhead when backtracing. + // reference: https://www.cnblogs.com/812-xiao-wen/p/10544546.html + if i == j || i & 127 == 0 || backtrace { + let d = z.gcd(target); + if !d.is_one() && &d != target { + return (Some(d), i); + } + + // save state + s = a.clone(); + } + + // when tortoise catches up with hare, let hare jump to the next stop + if i == j { + b = a.clone(); + j <<= 1; + } + } + + (None, i) +} + +/// This function implements Shanks's square forms factorization (SQUFOF). +/// +/// The input is usually multiplied by a multiplier, and the multiplied integer should be put in +/// the `mul_target` argument. The multiplier can be choosen from `SQUFOF_MULTIPLIERS`, or other square-free odd numbers. +/// The returned values are the factor and the count of passed iterations. +/// +/// The max iteration can be choosed as 2*n^(1/4), based on Theorem 4.22 from \[1\]. +/// +/// # Examples +/// +/// ``` +/// use num_prime::factor::squfof; +/// +/// let (factor, _iterations) = squfof(&11111u32, 11111u32, 100); +/// assert_eq!(factor, Some(41)); // 11111 = 41 × 271 +/// ``` +/// +/// Reference: Gower, J., & Wagstaff Jr, S. (2008). Square form factorization. +/// In \[1\] [Mathematics of Computation](https://homes.cerias.purdue.edu/~ssw/gowerthesis804/wthe.pdf) +/// or \[2\] [his thesis](https://homes.cerias.purdue.edu/~ssw/gowerthesis804/wthe.pdf) +/// The code is from \[3\] [Rosetta code](https://rosettacode.org/wiki/Square_form_factorization) +pub fn squfof( + target: &T, + mul_target: T, + max_iter: usize, +) -> (Option, usize) +where + for<'r> &'r T: RefNum, +{ + assert!( + &mul_target.is_multiple_of(target), + "mul_target should be multiples of target" + ); + let rd = Roots::sqrt(&mul_target); // root of k*N + + /// Reduction operator for binary quadratic forms. It's equivalent to + /// the one used in the `num-irrational` crate, in a little different form. + /// + /// This function reduces (a, b, c) = (qm1, p, q), updates qm1 and q, returns new p. + #[inline] + fn rho(rd: &T, p: &T, q: &mut T, qm1: &mut T) -> T + where + for<'r> &'r T: RefNum, + { + let b = (rd + p).div_floor(&*q); + let new_p = &b * &*q - p; + let new_q = if p > &new_p { + &*qm1 + b * (p - &new_p) + } else { + &*qm1 - b * (&new_p - p) + }; + + *qm1 = std::mem::replace(q, new_q); + new_p + } + + // forward loop, search principal cycle + let (mut p, mut q, mut qm1) = (rd.clone(), &mul_target - &rd * &rd, T::one()); + if q.is_zero() { + // shortcut for perfect square + return (Some(rd), 0); + } + + for i in 1..max_iter { + p = rho(&rd, &p, &mut q, &mut qm1); + if i.is_odd() { + if let Some(rq) = q.sqrt_exact() { + let b = (&rd - &p) / &rq; + let mut u = b * &rq + &p; + let (mut v, mut vm1) = ((&mul_target - &u * &u) / &rq, rq); + + // backward loop, search ambiguous cycle + loop { + let new_u = rho(&rd, &u, &mut v, &mut vm1); + if new_u == u { + break; + } else { + u = new_u; + } + } + + let d = target.gcd(&u); + if d > T::one() && &d < target { + return (Some(d), i); + } + } + } + } + (None, max_iter) +} + +/// Good squfof multipliers sorted by efficiency descendingly, from Dana Jacobsen. +/// +/// Note: square-free odd numbers are suitable as SQUFOF multipliers +pub const SQUFOF_MULTIPLIERS: [u16; 38] = [ + 3 * 5 * 7 * 11, + 3 * 5 * 7, + 3 * 5 * 7 * 11 * 13, + 3 * 5 * 7 * 13, + 3 * 5 * 7 * 11 * 17, + 3 * 5 * 11, + 3 * 5 * 7 * 17, + 3 * 5, + 3 * 5 * 7 * 11 * 19, + 3 * 5 * 11 * 13, + 3 * 5 * 7 * 19, + 3 * 5 * 7 * 13 * 17, + 3 * 5 * 13, + 3 * 7 * 11, + 3 * 7, + 5 * 7 * 11, + 3 * 7 * 13, + 5 * 7, + 3 * 5 * 17, + 5 * 7 * 13, + 3 * 5 * 19, + 3 * 11, + 3 * 7 * 17, + 3, + 3 * 11 * 13, + 5 * 11, + 3 * 7 * 19, + 3 * 13, + 5, + 5 * 11 * 13, + 5 * 7 * 19, + 5 * 13, + 7 * 11, + 7, + 3 * 17, + 7 * 13, + 11, + 1, +]; + +/// William Hart's one line factorization algorithm for 64 bit integers. +/// +/// The number to be factored could be multiplied by a smooth number (coprime to the target) +/// to speed up, put the multiplied number in the `mul_target` argument. A good multiplier given by Hart is 480. +/// `iters` determine the range for iterating the inner multiplier itself. The returned values are the factor +/// and the count of passed iterations. +/// +/// +/// The one line factorization algorithm is especially good at factoring semiprimes with form pq, +/// where p = `next_prime(c^a+d1`), p = `next_prime(c^b+d2`), a and b are close, and c, d1, d2 are small integers. +/// +/// # Examples +/// +/// ``` +/// use num_prime::factor::one_line; +/// +/// let (factor, _iterations) = one_line(&11111u32, 11111u32, 100); +/// assert_eq!(factor, Some(271)); // 11111 = 41 × 271 +/// ``` +/// +/// Reference: Hart, W. B. (2012). A one line factoring algorithm. Journal of the Australian Mathematical Society, 92(1), 61-69. doi:10.1017/S1446788712000146 +// TODO: add multipliers preset for one_line method? +pub fn one_line( + target: &T, + mul_target: T, + max_iter: usize, +) -> (Option, usize) +where + for<'r> &'r T: RefNum, +{ + assert!( + &mul_target.is_multiple_of(target), + "mul_target should be multiples of target" + ); + + let mut ikn = mul_target.clone(); + for i in 1..max_iter { + let s = ikn.sqrt() + T::one(); // assuming target is not perfect square + + // Use checked multiplication to prevent overflow + let s_squared = if let Some(result) = s.checked_mul(&s) { + result + } else { + // If s*s would overflow, this method won't work for this range + return (None, i); + }; + let m = s_squared - &ikn; + if let Some(t) = m.sqrt_exact() { + let g = target.gcd(&(s - t)); + if !g.is_one() && &g != target { + return (Some(g), i); + } + } + + // prevent overflow + ikn = if let Some(n) = ikn.checked_add(&mul_target) { + n + } else { + return (None, i); + } + } + (None, max_iter) +} + +// TODO: ECM, (self initialize) Quadratic sieve, Lehman's Fermat(https://en.wikipedia.org/wiki/Fermat%27s_factorization_method, n_factor_lehman) +// REF: https://pypi.org/project/primefac/ +// http://flintlib.org/doc/ulong_extras.html#factorisation +// https://github.com/zademn/facto-rs/ +// https://github.com/elmomoilanen/prime-factorization +// https://cseweb.ucsd.edu/~ethome/teaching/2022-cse-291-14/ +#[cfg(test)] +mod tests { + use super::*; + use crate::mint::SmallMint; + use num_modular::MontgomeryInt; + use rand::random; + + #[test] + fn pollard_rho_test() { + assert_eq!(pollard_rho(&8051u16, 2, 1, 100).0, Some(97)); + assert!(matches!(pollard_rho(&8051u16, random(), 1, 100).0, Some(i) if i == 97 || i == 83)); + assert_eq!(pollard_rho(&455_459_u32, 2, 1, 100).0, Some(743)); + + // Mint test + for _ in 0..10 { + let target = random::() | 1; + let start = random::() % target; + let offset = random::() % target; + + let expect = pollard_rho(&target, start, offset, 65536); + let mint_result = pollard_rho( + &SmallMint::from(target), + MontgomeryInt::new(start, &target).into(), + MontgomeryInt::new(offset, &target).into(), + 65536, + ); + assert_eq!(expect.0, mint_result.0.map(|v| v.value())); + } + } + + #[test] + fn squfof_test() { + // case from wikipedia + assert_eq!(squfof(&11111u32, 11111u32, 100).0, Some(41)); + + // cases from https://rosettacode.org/wiki/Square_form_factorization + let cases: Vec = vec![ + 2501, + 12851, + 13289, + 75301, + 120_787, + 967_009, + 997_417, + 7_091_569, + 5_214_317, + 20_834_839, + 23_515_517, + 33_409_583, + 44_524_219, + 13_290_059, + 223_553_581, + 2_027_651_281, + 11_111_111_111, + 100_895_598_169, + 60_012_462_237_239, + 287_129_523_414_791, + 9_007_199_254_740_931, + 11_111_111_111_111_111, + 314_159_265_358_979_323, + 384_307_168_202_281_507, + 419_244_183_493_398_773, + 658_812_288_346_769_681, + 922_337_203_685_477_563, + 1_000_000_000_000_000_127, + 1_152_921_505_680_588_799, + 1_537_228_672_809_128_917, + // this case should success at step 276, from https://rosettacode.org/wiki/Talk:Square_form_factorization + 4_558_849, + ]; + for n in cases { + let d = squfof(&n, n, 40000) + .0 + .or(squfof(&n, 3 * n, 40000).0) + .or(squfof(&n, 5 * n, 40000).0) + .or(squfof(&n, 7 * n, 40000).0) + .or(squfof(&n, 11 * n, 40000).0); + assert!(d.is_some(), "{}", n); + } + } + + #[test] + fn one_line_test() { + assert_eq!(one_line(&11111u32, 11111u32, 100).0, Some(271)); + } + + // --- one_line with overflow via checked_add --- + #[test] + fn one_line_overflow() { + // Use a u64 target large enough that repeated addition overflows + let n = u64::MAX / 4 + 1; // ~4.6e18, adding 5 times overflows u64 + let result = one_line(&n, n, 1000); + // Should return None (overflow triggered early exit via checked_add) + assert!(result.0.is_none()); + } + + #[test] + fn one_line_with_multiplier() { + // Use multiplier 480 as recommended + let n = 11111u32; + let result = one_line(&n, n * 480, 100); + assert!(result.0.is_some()); + let f = result.0.unwrap(); + assert!(n % f == 0 && f > 1 && f < n); + } + + // --- trial_division with limit=None (no limit path) --- + #[test] + fn trial_division_no_limit() { + let primes: Vec = vec![2, 3, 5, 7, 11, 13]; + let (factors, residual) = trial_division(primes.into_iter(), 2 * 3 * 5 * 7u64, None); + assert!(residual.is_ok()); + assert_eq!(residual.unwrap(), 1); + assert_eq!(factors[&2], 1); + assert_eq!(factors[&3], 1); + assert_eq!(factors[&5], 1); + assert_eq!(factors[&7], 1); + } + + // --- trial_division where residual is 1 (fully factored) --- + #[test] + fn trial_division_residual_one() { + let primes: Vec = vec![2, 3, 5]; + let (factors, residual) = trial_division(primes.into_iter(), 60u64, Some(100)); + assert!(residual.is_ok()); + assert_eq!(residual.unwrap(), 1); + assert_eq!(factors[&2], 2); + assert_eq!(factors[&3], 1); + assert_eq!(factors[&5], 1); + } + + // --- trial_division where bound exceeds sqrt (factored=true with residual prime) --- + #[test] + fn trial_division_bound_exceeds_sqrt() { + // 91 = 7 * 13. Primes up to 13 will factor it, and 13 > sqrt(91) ~ 9.5 + let primes: Vec = vec![2, 3, 5, 7, 11, 13]; + let (factors, residual) = trial_division(primes.into_iter(), 91u64, Some(100)); + assert!(residual.is_ok()); + // After dividing by 7, residual is 13, and bound > sqrt means factored + assert_eq!(factors[&7], 1); + assert_eq!(residual.unwrap(), 13); + } + + #[test] + fn trial_division_prime_target() { + // 97 is prime. Primes up to 10 > sqrt(97) ~ 9.85, so factored=true + let primes: Vec = vec![2, 3, 5, 7, 11]; + let (factors, residual) = trial_division(primes.into_iter(), 97u64, Some(100)); + assert!(residual.is_ok()); + assert!(factors.is_empty()); + assert_eq!(residual.unwrap(), 97); + } + + // --- squfof with perfect square input --- + #[test] + fn squfof_perfect_square() { + // Perfect square: q.is_zero() shortcut + let result = squfof(&49u64, 49u64, 100); + assert_eq!(result.0, Some(7)); + assert_eq!(result.1, 0); // should return immediately + } + + #[test] + fn squfof_perfect_square_large() { + let n = 10201u64; // 101^2 + let result = squfof(&n, n, 100); + assert_eq!(result.0, Some(101)); + assert_eq!(result.1, 0); + } + + // --- pollard_rho with known backtracing scenario --- + #[test] + fn pollard_rho_various_starts() { + // Test multiple start/offset combinations to increase path coverage + let target = 8051u32; + for start in [1u32, 2, 3, 5, 7, 11, 13] { + for offset in [1u32, 2, 3, 5, 7] { + let (result, _) = pollard_rho(&target, start, offset, 10000); + if let Some(f) = result { + assert!(target % f == 0 && f > 1 && f < target); + } + } + } + } + + #[test] + fn pollard_rho_loop_detection() { + // Case where a == b (cycle detected) should return None + // Start 0, offset 0: f(x) = x^2 + 0 mod n, starting from 0 => always 0, quick cycle + let (result, _) = pollard_rho(&15u32, 0, 0, 100); + // This should either find a factor or hit the cycle + // Just verify it doesn't panic + let _ = result; + } + + // --- trial_division with small limit --- + #[test] + fn trial_division_limited() { + // Limit smaller than sqrt means not fully factored + let primes: Vec = vec![2, 3, 5, 7, 11, 13]; + // 1001 = 7 * 11 * 13, sqrt(1001) ~ 31.6 + // With limit 10, we can only find factor 7, then residual 143 = 11*13 + let (factors, residual) = trial_division(primes.into_iter(), 1001u64, Some(10)); + assert!(residual.is_err()); // not fully factored + assert_eq!(factors[&7], 1); + assert_eq!(residual.unwrap_err(), 143); + } +} diff --git a/vendor/num-prime/src/integer.rs b/vendor/num-prime/src/integer.rs new file mode 100644 index 0000000..8856eac --- /dev/null +++ b/vendor/num-prime/src/integer.rs @@ -0,0 +1,391 @@ +//! Backend implementations for integers + +#[cfg(feature = "big-int")] +use crate::tables::{CUBIC_MODULI, CUBIC_RESIDUAL, QUAD_MODULI, QUAD_RESIDUAL}; +use crate::traits::{BitTest, ExactRoots}; + +use num_integer::Roots; + +#[cfg(feature = "big-int")] +use num_bigint::{BigInt, BigUint, ToBigInt}; +#[cfg(feature = "big-int")] +use num_traits::{One, Signed, ToPrimitive, Zero}; + +macro_rules! impl_bittest_prim { + ($($T:ty)*) => {$( + impl BitTest for $T { + #[inline] + fn bits(&self) -> usize { + (<$T>::BITS - self.leading_zeros()) as usize + } + #[inline] + fn bit(&self, position: usize) -> bool { + self & (1 << position) > 0 + } + #[inline] + fn trailing_zeros(&self) -> usize { + <$T>::trailing_zeros(*self) as usize + } + } + )*} +} +impl_bittest_prim!(u8 u16 u32 u64 u128 usize); + +#[cfg(feature = "big-int")] +impl BitTest for BigUint { + fn bit(&self, position: usize) -> bool { + self.bit(position as u64) + } + fn bits(&self) -> usize { + BigUint::bits(self) as usize + } + #[inline] + fn trailing_zeros(&self) -> usize { + match BigUint::trailing_zeros(self) { + Some(a) => a as usize, + None => 0, + } + } +} + +macro_rules! impl_exactroot_prim { + ($($T:ty)*) => {$( + impl ExactRoots for $T { + fn nth_root_exact(&self, n: u32) -> Option { + // For even roots of negative numbers, return None instead of panicking + if self < &0 && n % 2 == 0 { + return None; + } + let r = self.nth_root(n); + if &r.clone().pow(n) == self { + Some(r) + } else { + None + } + } + fn sqrt_exact(&self) -> Option { + if *self == 0 { return Some(0); } + if self < &0 { return None; } + let shift = self.trailing_zeros(); + + // the general form of any square number is (2^(2m))(8N+1) + if shift & 1 == 1 { return None; } + if (self >> shift) & 7 != 1 { return None; } + self.nth_root_exact(2) + } + } + )*}; + // TODO: it might worth use QUAD_RESIDUE and CUBIC_RESIDUE for large size + // primitive integers, need benchmark +} +impl_exactroot_prim!(u8 u16 u32 u64 u128 usize i8 i16 i32 i64 i128 isize); + +#[cfg(feature = "big-int")] +impl ExactRoots for BigUint { + fn sqrt_exact(&self) -> Option { + // shortcuts + if self.is_zero() { + return Some(BigUint::zero()); + } + if let Some(v) = self.to_u64() { + return v.sqrt_exact().map(BigUint::from); + } + + // check mod 2 + let shift = self.trailing_zeros().unwrap(); + if shift & 1 == 1 { + return None; + } + if !((self >> shift) & BigUint::from(7u8)).is_one() { + return None; + } + + // check other moduli + #[cfg(not(feature = "big-table"))] + for (m, res) in QUAD_MODULI.iter().zip(QUAD_RESIDUAL) { + // need to &63 since we have 65 in QUAD_MODULI + if (res >> ((self % m).to_u8().unwrap() & 63)) & 1 == 0 { + return None; + } + } + #[cfg(feature = "big-table")] + for (m, res) in QUAD_MODULI.iter().zip(QUAD_RESIDUAL) { + let rem = (self % m).to_u16().unwrap(); + if (res[(rem / 64) as usize] >> (rem % 64)) & 1 == 0 { + return None; + } + } + + self.nth_root_exact(2) + } + + fn cbrt_exact(&self) -> Option { + // shortcuts + if self.is_zero() { + return Some(BigUint::zero()); + } + if let Some(v) = self.to_u64() { + return v.cbrt_exact().map(BigUint::from); + } + + // check mod 2 + let shift = self.trailing_zeros().unwrap(); + if shift % 3 != 0 { + return None; + } + + // check other moduli + #[cfg(not(feature = "big-table"))] + for (m, res) in CUBIC_MODULI.iter().zip(CUBIC_RESIDUAL) { + if (res >> (self % m).to_u8().unwrap()) & 1 == 0 { + return None; + } + } + #[cfg(feature = "big-table")] + for (m, res) in CUBIC_MODULI.iter().zip(CUBIC_RESIDUAL) { + let rem = (self % m).to_u16().unwrap(); + if (res[(rem / 64) as usize] >> (rem % 64)) & 1 == 0 { + return None; + } + } + + self.nth_root_exact(3) + } +} + +#[cfg(feature = "big-int")] +impl ExactRoots for BigInt { + fn nth_root_exact(&self, n: u32) -> Option { + // For even roots of negative numbers, return None instead of panicking + if self.is_negative() && n % 2 == 0 { + return None; + } + + // For odd roots, handle negative numbers by taking the root of the magnitude + // and then applying the sign + if self.is_negative() { + self.magnitude() + .nth_root_exact(n) + .and_then(|u| u.to_bigint()) + .map(|v| -v) + } else { + self.magnitude() + .nth_root_exact(n) + .and_then(|u| u.to_bigint()) + } + } + fn sqrt_exact(&self) -> Option { + self.to_biguint() + .and_then(|u| u.sqrt_exact()) + .and_then(|u| u.to_bigint()) + } + fn cbrt_exact(&self) -> Option { + self.magnitude() + .cbrt_exact() + .and_then(|u| u.to_bigint()) + .map(|v| if self.is_negative() { -v } else { v }) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn exact_root_test() { + // some simple tests + assert!(ExactRoots::sqrt_exact(&3u8).is_none()); + assert!(matches!(ExactRoots::sqrt_exact(&4u8), Some(2))); + assert!(matches!(ExactRoots::sqrt_exact(&9u8), Some(3))); + assert!(ExactRoots::sqrt_exact(&18u8).is_none()); + assert!(ExactRoots::sqrt_exact(&3i8).is_none()); + assert!(matches!(ExactRoots::sqrt_exact(&4i8), Some(2))); + assert!(matches!(ExactRoots::sqrt_exact(&9i8), Some(3))); + assert!(ExactRoots::sqrt_exact(&18i8).is_none()); + + // test fast implementations of sqrt against nth_root + for _ in 0..100 { + let x = rand::random::(); + assert_eq!( + ExactRoots::sqrt_exact(&x), + ExactRoots::nth_root_exact(&x, 2) + ); + assert_eq!( + ExactRoots::cbrt_exact(&x), + ExactRoots::nth_root_exact(&x, 3) + ); + let x = rand::random::(); + assert_eq!( + ExactRoots::cbrt_exact(&x), + ExactRoots::nth_root_exact(&x, 3) + ); + } + // test perfect powers + for _ in 0..100 { + let x = u64::from(rand::random::()); + assert!(matches!(ExactRoots::sqrt_exact(&(x * x)), Some(v) if v == x)); + let x = i64::from(rand::random::()); + assert!(matches!(ExactRoots::cbrt_exact(&(x * x * x)), Some(v) if v == x)); + } + // test non-perfect powers + for _ in 0..100 { + let x = u64::from(rand::random::()); + let y = u64::from(rand::random::()); + if x == y { + continue; + } + assert!(ExactRoots::sqrt_exact(&(x * y)).is_none()); + } + + #[cfg(feature = "big-int")] + { + use num_bigint::RandBigInt; + let mut rng = rand::thread_rng(); + // test fast implementations of sqrt against nth_root + for _ in 0..10 { + let x = rng.gen_biguint(150); + assert_eq!( + ExactRoots::sqrt_exact(&x), + ExactRoots::nth_root_exact(&x, 2) + ); + assert_eq!( + ExactRoots::cbrt_exact(&x), + ExactRoots::nth_root_exact(&x, 3) + ); + let x = rng.gen_bigint(150); + assert_eq!( + ExactRoots::cbrt_exact(&x), + ExactRoots::nth_root_exact(&x, 3) + ); + } + // test perfect powers + for _ in 0..10 { + let x = rng.gen_biguint(150); + assert!(matches!(ExactRoots::sqrt_exact(&(&x * &x)), Some(v) if v == x)); + let x = rng.gen_biguint(150); + assert!( + matches!(ExactRoots::cbrt_exact(&(&x * &x * &x)), Some(v) if v == x), + "failed at {}", + x + ); + } + // test non-perfect powers + for _ in 0..10 { + let x = rng.gen_biguint(150); + let y = rng.gen_biguint(150); + if x == y { + continue; + } + assert!(ExactRoots::sqrt_exact(&(x * y)).is_none()); + } + } + } + + #[test] + fn test_nth_root_exact_negative_even_root() { + // Test for issue #25: nth_root_exact(2) should return None for negative numbers + // instead of panicking + let result = (-1i32).nth_root_exact(2); + assert!( + result.is_none(), + "nth_root_exact(2) should return None for negative numbers" + ); + + // Test other negative numbers with even roots + let result = (-4i32).nth_root_exact(2); + assert!( + result.is_none(), + "nth_root_exact(2) should return None for negative numbers" + ); + + let result = (-8i32).nth_root_exact(4); + assert!( + result.is_none(), + "nth_root_exact(4) should return None for negative numbers" + ); + + // Test that odd roots of negative numbers still work + let result = (-8i32).nth_root_exact(3); + assert_eq!( + result, + Some(-2), + "nth_root_exact(3) should work for negative numbers" + ); + + let result = (-27i32).nth_root_exact(3); + assert_eq!( + result, + Some(-3), + "nth_root_exact(3) should work for negative numbers" + ); + } + + #[test] + fn test_nth_root_exact_all_signed_types() { + // Test all signed integer types with even roots of negative numbers + assert_eq!((-1i8).nth_root_exact(2), None); + assert_eq!((-1i16).nth_root_exact(2), None); + assert_eq!((-1i32).nth_root_exact(2), None); + assert_eq!((-1i64).nth_root_exact(2), None); + assert_eq!((-1i128).nth_root_exact(2), None); + assert_eq!((-1isize).nth_root_exact(2), None); + + // Test odd roots work correctly + assert_eq!((-8i32).nth_root_exact(3), Some(-2)); + assert_eq!((-32i32).nth_root_exact(5), Some(-2)); + + // Test positive cases still work + assert_eq!(16i32.nth_root_exact(4), Some(2)); + assert_eq!(32i32.nth_root_exact(5), Some(2)); + } + + #[test] + fn test_sqrt_exact_zero() { + // sqrt_exact(0) must return Some(0) for all primitive types; + // previously this reached `self >> trailing_zeros()` with + // shift == bit width, which is an invalid shift. + assert_eq!(0u8.sqrt_exact(), Some(0)); + assert_eq!(0u16.sqrt_exact(), Some(0)); + assert_eq!(0u32.sqrt_exact(), Some(0)); + assert_eq!(0u64.sqrt_exact(), Some(0)); + assert_eq!(0u128.sqrt_exact(), Some(0)); + assert_eq!(0usize.sqrt_exact(), Some(0)); + assert_eq!(0i8.sqrt_exact(), Some(0)); + assert_eq!(0i16.sqrt_exact(), Some(0)); + assert_eq!(0i32.sqrt_exact(), Some(0)); + assert_eq!(0i64.sqrt_exact(), Some(0)); + assert_eq!(0i128.sqrt_exact(), Some(0)); + assert_eq!(0isize.sqrt_exact(), Some(0)); + + assert!(0u64.is_square()); + assert!(0i64.is_square()); + + // neighboring behavior is unchanged + assert_eq!(1u64.sqrt_exact(), Some(1)); + assert_eq!(4u64.sqrt_exact(), Some(2)); + assert_eq!(9u64.sqrt_exact(), Some(3)); + assert_eq!(16u64.sqrt_exact(), Some(4)); + assert_eq!(2u64.sqrt_exact(), None); + assert_eq!(3u64.sqrt_exact(), None); + assert_eq!(15u64.sqrt_exact(), None); + assert_eq!((-1i32).sqrt_exact(), None); + assert_eq!((-4i32).sqrt_exact(), None); + } + + #[test] + #[cfg(feature = "big-int")] + fn test_nth_root_exact_bigint_negative() { + use num_bigint::BigInt; + + // Test even roots return None for negative BigInt + assert_eq!(BigInt::from(-1).nth_root_exact(2), None); + assert_eq!(BigInt::from(-16).nth_root_exact(4), None); + + // Test odd roots work for negative BigInt + assert_eq!(BigInt::from(-8).nth_root_exact(3), Some(BigInt::from(-2))); + assert_eq!( + BigInt::from(-1000000000i64).nth_root_exact(3), + Some(BigInt::from(-1000i32)) + ); + } +} diff --git a/vendor/num-prime/src/lib.rs b/vendor/num-prime/src/lib.rs new file mode 100644 index 0000000..68dbcd4 --- /dev/null +++ b/vendor/num-prime/src/lib.rs @@ -0,0 +1,93 @@ +// #![doc = include_str!("../README.md")] + +//! This crate provides utilities for prime related functionalities and some basic number theoretic functions: +//! - Primality testing +//! - [Primality check][nt_funcs::is_prime] +//! - [Deterministic primality check of `u64` integers][nt_funcs::is_prime64] (using a very fast hashing algorithm) +//! - [Fermat probable prime test][PrimalityUtils::is_prp] +//! - [Miller-rabin probable prime test][PrimalityUtils::is_sprp] +//! - ([strong][PrimalityUtils::is_slprp]/[extra strong][PrimalityUtils::is_eslprp]) [Lucas probable prime test][PrimalityUtils::is_lprp] +//! - [Baillie-PSW test][PrimalityTestConfig::bpsw] +//! - [Sophie Germain safe prime test][nt_funcs::is_safe_prime] +//! - Primes generation and indexing +//! - [A naive implementation of the sieve of Eratosthenes][buffer::NaiveBuffer] +//! - [Unified API to support other prime generation backends][PrimeBuffer] +//! - [Generate random (safe) primes][traits::RandPrime] +//! - Find [previous prime][nt_funcs::prev_prime] / [next prime][nt_funcs::next_prime] +//! - [Integer factorization][nt_funcs::factors] +//! - [Trial division][factor::trial_division] +//! - [Pollard's rho algorithm][factor::pollard_rho] +//! - [Shanks's square forms factorization (SQUFOF)][factor::squfof] +//! - [Hart's one line algorithm][factor::one_line] +//! - [Fast factorization of `u64` integers][nt_funcs::factorize64] +//! - Number theoretic functions +//! - [Prime Pi function][nt_funcs::prime_pi], its [estimation](nt_funcs::prime_pi_est), and its [bounds](nt_funcs::prime_pi_bounds) +//! - [Nth Prime][nt_funcs::nth_prime], its [estimation](nt_funcs::nth_prime_est), and its [bounds](nt_funcs::nth_prime_bounds) +//! - [Moebius function][nt_funcs::moebius] +//! +//! # Usage +//! Most number theoretic functions can be found in [`nt_funcs`] module, while some +//! of them are implemented as member function of [`num_modular::ModularOps`] or [`PrimalityUtils`]. +//! +//! Example code for primality testing and integer factorization: +//! ```rust +//! use num_prime::{PrimalityTestConfig, FactorizationConfig}; +//! use num_prime::nt_funcs::{is_prime, factorize, factors}; +//! +//! let p = 2u128.pow(89) - 1; // a prime number +//! assert!(is_prime(&p, None).probably()); // use default primality check config +//! assert!(is_prime(&p, Some(PrimalityTestConfig::bpsw())).probably()); // BPSW test +//! +//! let c = 2u128.pow(83) - 1; // a composite number +//! assert!(!is_prime(&c, None).probably()); +//! let fac = factorize(c); // infallible factorization with default configuration +//! assert_eq!(fac.len(), 2); // 2^83-1 = 167 * 57912614113275649087721 +//! +//! let config = FactorizationConfig::strict(); +//! let (fac, rem) = factors(c, Some(config)); // fallible factorization with customized configuration +//! assert!(fac.len() == 2 && rem.is_none()); +//! ``` +//! +//! # Backends +//! This crate is built with modular integer type and prime generation backends. +//! Most functions support generic input types, and support for `num-bigint` is +//! also available (it's an optional feature). To make a new integer type supported +//! by this crate, the type has to implement [`detail::PrimalityBase`] and [`detail::PrimalityRefBase`]. +//! For prime generation, there's a builtin implementation (see [buffer] module), +//! but you can also use other backends (such as `primal`) as long as it implements [`PrimeBuffer`]. +//! +//! # Optional Features +//! - `big-int` (default): Enable this feature to support `num-bigint::BigUint` as integer inputs. +//! - `big-table` (default): Enable this feature to allow compiling large precomputed tables which +//! could improve the speed of various functions with the cost of larger memory footprint. +//! + +#![allow(clippy::redundant_clone)] + +pub mod buffer; +pub mod factor; +pub mod nt_funcs; + +mod integer; +mod mint; +#[cfg(feature = "big-int")] +mod montgomery; +mod primality; +mod rand; +mod splitmix64; +mod tables; +mod traits; +mod util; + +pub use traits::*; +pub mod detail { + //! Implementation details for this crate. + //! + //! The structs and traits in this module are exposed for public use, although they are no + //! designed for such usage. User-friendly is not a goal and backward-compatilibity is not + //! strictly maintained here. Some traits in this module can be used to extend `num-prime` + //! with new backends. + pub use super::mint::{Mint, SmallMint}; + pub use super::primality::{LucasUtils, PrimalityBase, PrimalityRefBase}; + pub use super::tables::SMALL_PRIMES; +} diff --git a/vendor/num-prime/src/mint.rs b/vendor/num-prime/src/mint.rs new file mode 100644 index 0000000..6a09519 --- /dev/null +++ b/vendor/num-prime/src/mint.rs @@ -0,0 +1,1211 @@ +//! Wrapper of integer to makes it efficient in modular arithmetics but still have the same +//! API of normal integers. + +use core::ops::{Add, Div, Mul, Neg, Rem, Shr, Sub}; +use either::{Either, Left, Right}; +use num_integer::{Integer, Roots}; +use num_modular::{ + ModularCoreOps, ModularInteger, ModularPow, ModularSymbols, ModularUnaryOps, Montgomery, + ReducedInt, Reducer, +}; +use num_traits::{FromPrimitive, Num, One, Pow, ToPrimitive, Zero}; + +use crate::{BitTest, ExactRoots}; + +/// Integer with fast modular arithmetics support, based on [`num_modular::MontgomeryInt`] under the hood +/// +/// This struct only designed to be working with this crate. Most binary operators assume that +/// the modulus of two operands (when in montgomery form) are the same, and most implicit conversions +/// between conventional form and montgomery form will be forbidden +#[derive(Debug, Clone, Copy)] +pub struct Mint>(Either>); + +impl> From for Mint { + #[inline(always)] + fn from(v: T) -> Self { + Self(Left(v)) + } +} +impl> From> for Mint { + #[inline(always)] + fn from(v: ReducedInt) -> Self { + Self(Right(v)) + } +} + +#[inline(always)] +fn left_only>(lhs: Mint, rhs: Mint) -> (T, T) { + match (lhs.0, rhs.0) { + (Left(v1), Left(v2)) => (v1, v2), + (_, _) => unreachable!(), + } +} + +#[inline(always)] +fn left_ref_only<'a, T: Integer, R: Reducer>( + lhs: &'a Mint, + rhs: &'a Mint, +) -> (&'a T, &'a T) { + match (&lhs.0, &rhs.0) { + (Left(v1), Left(v2)) => (v1, v2), + (_, _) => unreachable!(), + } +} + +macro_rules! forward_binops_left_ref_only { + ($method:ident) => { + #[inline(always)] + fn $method(&self, other: &Self) -> Self { + let (v1, v2) = left_ref_only(self, other); + Self(Left(v1.$method(v2))) + } + }; + ($method:ident => $return:ty) => { + #[inline(always)] + fn $method(&self, other: &Self) -> $return { + let (v1, v2) = left_ref_only(self, other); + v1.$method(v2) + } + }; +} + +macro_rules! forward_uops_ref { + ($method:ident => $return:ty) => { + #[inline(always)] + fn $method(&self) -> $return { + match &self.0 { + Left(v) => v.$method(), + Right(m) => m.residue().$method(), + } + } + }; +} + +impl> PartialEq for Mint { + fn eq(&self, other: &Self) -> bool { + match (&self.0, &other.0) { + (Left(v1), Left(v2)) => v1 == v2, + (Right(v1), Right(v2)) => v1 == v2, + (_, _) => unreachable!(), // force optimization of equality test + } + } +} +impl> Eq for Mint {} + +impl + Clone> PartialOrd for Mint { + fn partial_cmp(&self, other: &Self) -> Option { + Some(self.cmp(other)) + } +} +impl + Clone> Ord for Mint { + fn cmp(&self, other: &Self) -> std::cmp::Ordering { + match (&self.0, &other.0) { + (Left(v1), Left(v2)) => v1.cmp(v2), + (Left(v1), Right(v2)) => v1.cmp(&v2.residue()), + (Right(v1), Left(v2)) => v1.residue().cmp(v2), + (Right(v1), Right(v2)) => v1.residue().cmp(&v2.residue()), + } + } +} + +impl + Clone> Mint { + #[inline(always)] + pub fn value(&self) -> T { + match &self.0 { + Left(v) => v.clone(), + Right(m) => m.residue(), + } + } +} + +// forward binary operators by converting result to MontgomeryInt whenever possible +macro_rules! forward_binops_right { + (impl $imp:ident, $method:ident) => { + impl + Clone> $imp for Mint { + type Output = Self; + #[inline] + fn $method(self, rhs: Self) -> Self::Output { + Self(match (self.0, rhs.0) { + (Left(v1), Left(v2)) => Left(v1.$method(v2)), + (Left(v1), Right(v2)) => Right(v2.convert(v1).$method(v2)), + (Right(v1), Left(v2)) => { + let v2 = v1.convert(v2); + Right(v1.$method(v2)) + } + (Right(v1), Right(v2)) => Right(v1.$method(v2)), + }) + } + } + + impl $imp<&'r T, Output = T>, R: Reducer + Clone> + $imp<&Self> for Mint + { + type Output = Mint; + #[inline] + fn $method(self, rhs: &Self) -> Self::Output { + Mint(match (self.0, &rhs.0) { + (Left(v1), Left(v2)) => Left(v1.$method(v2)), + (Left(v1), Right(v2)) => Right(v2.convert(v1).$method(v2)), + (Right(v1), Left(v2)) => { + let v2 = v1.convert(v2.clone()); + Right(v1.$method(v2)) + } + (Right(v1), Right(v2)) => Right(v1.$method(v2)), + }) + } + } + + impl + Clone> $imp> for &Mint { + type Output = Mint; + // FIXME: additional clone here due to https://github.com/rust-lang/rust/issues/39959 + // (same for ref & ref operation below, and those for Div and Rem) + #[inline] + fn $method(self, rhs: Mint) -> Self::Output { + Mint(match (&self.0, rhs.0) { + (Left(v1), Left(v2)) => Left(v1.clone().$method(v2)), + (Left(v1), Right(v2)) => Right(v2.convert(v1.clone()).$method(v2)), + (Right(v1), Left(v2)) => { + let v2 = v1.convert(v2); + Right(v1.clone().$method(v2)) + } + (Right(v1), Right(v2)) => Right(v1.$method(v2)), + }) + } + } + impl< + 'a, + 'b, + T: Integer + Clone + for<'r> $imp<&'r T, Output = T>, + R: Reducer + Clone, + > $imp<&'b Mint> for &'a Mint + { + type Output = Mint; + #[inline] + fn $method(self, rhs: &Mint) -> Self::Output { + Mint(match (&self.0, &rhs.0) { + (Left(v1), Left(v2)) => Left(v1.clone().$method(v2)), + (Left(v1), Right(v2)) => Right(v2.convert(v1.clone()).$method(v2)), + (Right(v1), Left(v2)) => { + let v2 = v1.convert(v2.clone()); + Right(v1.clone().$method(v2)) + } + (Right(v1), Right(v2)) => Right(v1.$method(v2)), + }) + } + } + }; +} + +forward_binops_right!(impl Add, add); +forward_binops_right!(impl Sub, sub); +forward_binops_right!(impl Mul, mul); + +impl> Div for Mint { + type Output = Self; + + #[inline] + fn div(self, rhs: Self) -> Self::Output { + let (v1, v2) = left_only(self, rhs); + Self(Left(v1.div(v2))) + } +} +impl Div<&'r T, Output = T>, R: Reducer> Div<&Self> for Mint { + type Output = Self; + + #[inline] + fn div(self, rhs: &Self) -> Self::Output { + match (self.0, &rhs.0) { + (Left(v1), Left(v2)) => Self(Left(v1.div(v2))), + (_, _) => unreachable!(), + } + } +} +impl> Div> for &Mint { + type Output = Mint; + + #[inline] + fn div(self, rhs: Mint) -> Self::Output { + match (&self.0, rhs.0) { + (Left(v1), Left(v2)) => Mint(Left(v1.clone().div(v2))), + (_, _) => unreachable!(), + } + } +} +impl Div<&'r T, Output = T>, R: Reducer> Div<&Mint> + for &Mint +{ + type Output = Mint; + #[inline] + fn div(self, rhs: &Mint) -> Self::Output { + match (&self.0, &rhs.0) { + (Left(v1), Left(v2)) => Mint(Left(v1.clone().div(v2))), + (_, _) => unreachable!(), + } + } +} + +impl + Clone> Rem for Mint { + type Output = Self; + + #[inline] + fn rem(self, rhs: Self) -> Self::Output { + match (self.0, rhs.0) { + (Left(v1), Left(v2)) => Self(Right(ReducedInt::new(v1, &v2))), + (Right(v1), Left(v2)) => { + debug_assert!(v1.modulus() == v2); + Self(Right(v1)) + } + (_, _) => unreachable!(), + } + } +} +impl + Clone> Rem<&Self> for Mint { + type Output = Self; + + #[inline] + fn rem(self, rhs: &Self) -> Self::Output { + match (self.0, &rhs.0) { + (Left(v1), Left(v2)) => Self(Right(ReducedInt::new(v1, v2))), + (Right(v1), Left(v2)) => { + debug_assert!(&v1.modulus() == v2); + Self(Right(v1)) + } + (_, _) => unreachable!(), + } + } +} +impl + Clone> Rem> for &Mint { + type Output = Mint; + + #[inline] + fn rem(self, rhs: Mint) -> Self::Output { + match (&self.0, rhs.0) { + (Left(v1), Left(v2)) => Mint(Right(ReducedInt::new(v1.clone(), &v2))), + (Right(v1), Left(v2)) => { + debug_assert!(v1.modulus() == v2); + Mint(Right(v1.clone())) + } + (_, _) => unreachable!(), + } + } +} +impl + Clone> Rem<&Mint> for &Mint { + type Output = Mint; + + #[inline] + fn rem(self, rhs: &Mint) -> Self::Output { + match (&self.0, &rhs.0) { + (Left(v1), Left(v2)) => Mint(Right(ReducedInt::new(v1.clone(), v2))), + (Right(v1), Left(v2)) => { + debug_assert!(&v1.modulus() == v2); + Mint(Right(v1.clone())) + } + (_, _) => unreachable!(), + } + } +} + +impl + Clone> Zero for Mint { + #[inline(always)] + fn zero() -> Self { + Self(Left(T::zero())) + } + #[inline(always)] + fn is_zero(&self) -> bool { + match &self.0 { + Left(v) => v.is_zero(), + Right(m) => m.is_zero(), + } + } +} + +impl + Clone> One for Mint { + #[inline(always)] + fn one() -> Self { + Self(Left(T::one())) + } + forward_uops_ref!(is_one => bool); +} + +impl + Clone> Num for Mint { + type FromStrRadixErr = ::FromStrRadixErr; + + #[inline(always)] + fn from_str_radix(str: &str, radix: u32) -> Result { + T::from_str_radix(str, radix).map(|v| Self(Left(v))) + } +} + +impl + Clone> Integer for Mint { + forward_binops_left_ref_only!(div_floor); + forward_binops_left_ref_only!(mod_floor); + forward_binops_left_ref_only!(lcm); + forward_binops_left_ref_only!(is_multiple_of => bool); + forward_uops_ref!(is_even => bool); + forward_uops_ref!(is_odd => bool); + + #[inline(always)] + fn div_rem(&self, other: &Self) -> (Self, Self) { + let (v1, v2) = left_ref_only(self, other); + let (q, r) = v1.div_rem(v2); + (Self(Left(q)), Self(Left(r))) + } + #[inline(always)] + fn gcd(&self, other: &Self) -> Self { + Self(Left(match (&self.0, &other.0) { + (Left(v1), Left(v2)) => v1.gcd(v2), + (Right(v1), Left(v2)) => v1.residue().gcd(v2), + (Left(v1), Right(v2)) => v1.gcd(&v2.residue()), + (Right(v1), Right(v2)) => v1.residue().gcd(&v2.residue()), + })) + } +} + +impl + Clone> Roots for Mint { + #[inline] + fn nth_root(&self, n: u32) -> Self { + match &self.0 { + Left(v) => Self(Left(v.nth_root(n))), + Right(_) => unreachable!(), + } + } +} + +impl> FromPrimitive for Mint { + #[inline] + fn from_f64(n: f64) -> Option { + T::from_f64(n).map(|v| Self(Left(v))) + } + #[inline] + fn from_i64(n: i64) -> Option { + T::from_i64(n).map(|v| Self(Left(v))) + } + #[inline] + fn from_u64(n: u64) -> Option { + T::from_u64(n).map(|v| Self(Left(v))) + } +} + +impl + Clone> ToPrimitive for Mint { + #[inline] + fn to_f64(&self) -> Option { + match &self.0 { + Left(v) => v.to_f64(), + Right(m) => m.residue().to_f64(), + } + } + #[inline] + fn to_i64(&self) -> Option { + match &self.0 { + Left(v) => v.to_i64(), + Right(m) => m.residue().to_i64(), + } + } + #[inline] + fn to_u64(&self) -> Option { + match &self.0 { + Left(v) => v.to_u64(), + Right(m) => m.residue().to_u64(), + } + } +} + +impl, R: Reducer> Pow for Mint { + type Output = Self; + #[inline] + fn pow(self, rhs: u32) -> Self::Output { + match self.0 { + Left(v) => Self(Left(v.pow(rhs))), + Right(_) => unreachable!(), + } + } +} + +impl + Clone> ExactRoots for Mint { + #[inline] + fn nth_root_exact(&self, n: u32) -> Option { + match &self.0 { + Left(v) => v.nth_root_exact(n).map(|v| Self(Left(v))), + Right(_) => unreachable!(), + } + } +} + +impl> BitTest for Mint { + #[inline] + fn bit(&self, position: usize) -> bool { + match &self.0 { + Left(v) => v.bit(position), + Right(_) => unreachable!(), + } + } + #[inline] + fn bits(&self) -> usize { + match &self.0 { + Left(v) => v.bits(), + Right(_) => unreachable!(), + } + } + #[inline] + fn trailing_zeros(&self) -> usize { + match &self.0 { + Left(v) => v.trailing_zeros(), + Right(_) => unreachable!(), + } + } +} + +impl, R: Reducer> Shr for Mint { + type Output = Self; + #[inline] + fn shr(self, rhs: usize) -> Self::Output { + match self.0 { + Left(v) => Self(Left(v >> rhs)), + Right(_) => unreachable!(), + } + } +} +impl, R: Reducer> Shr for &Mint { + type Output = Mint; + #[inline] + fn shr(self, rhs: usize) -> Self::Output { + match &self.0 { + Left(v) => Mint(Left(v.clone() >> rhs)), + Right(_) => unreachable!(), + } + } +} + +impl + Clone> ModularCoreOps<&Self, &Self> for Mint { + type Output = Self; + #[inline] + fn addm(self, rhs: &Self, m: &Self) -> Self::Output { + match (self.0, &rhs.0, &m.0) { + (Right(v1), Right(v2), Left(m)) => { + debug_assert!(&v1.modulus() == m && &v2.modulus() == m); + Self(Right(v1 + v2)) + } + (_, _, _) => unreachable!(), + } + } + #[inline] + fn subm(self, rhs: &Self, m: &Self) -> Self::Output { + match (self.0, &rhs.0, &m.0) { + (Right(v1), Right(v2), Left(m)) => { + debug_assert!(&v1.modulus() == m && &v2.modulus() == m); + Self(Right(v1 - v2)) + } + (_, _, _) => unreachable!(), + } + } + #[inline] + fn mulm(self, rhs: &Self, m: &Self) -> Self::Output { + match (self.0, &rhs.0, &m.0) { + (Right(v1), Right(v2), Left(m)) => { + debug_assert!(&v1.modulus() == m && &v2.modulus() == m); + Self(Right(v1 * v2)) + } + (_, _, _) => unreachable!(), + } + } +} +impl<'b, T: Integer + Clone, R: Reducer + Clone> ModularCoreOps<&'b Mint, &'b Mint> + for &Mint +{ + type Output = Mint; + #[inline] + fn addm(self, rhs: &Mint, m: &Mint) -> Self::Output { + match (&self.0, &rhs.0, &m.0) { + (Right(v1), Right(v2), Left(m)) => { + debug_assert!(&v1.modulus() == m && &v2.modulus() == m); + Mint(Right(v1 + v2)) + } + (_, _, _) => unreachable!(), + } + } + #[inline] + fn subm(self, rhs: &Mint, m: &Mint) -> Self::Output { + match (&self.0, &rhs.0, &m.0) { + (Right(v1), Right(v2), Left(m)) => { + debug_assert!(&v1.modulus() == m && &v2.modulus() == m); + Mint(Right(v1 - v2)) + } + (_, _, _) => unreachable!(), + } + } + #[inline] + fn mulm(self, rhs: &Mint, m: &Mint) -> Self::Output { + match (&self.0, &rhs.0, &m.0) { + (Right(v1), Right(v2), Left(m)) => { + debug_assert!(&v1.modulus() == m && &v2.modulus() == m); + Mint(Right(v1 * v2)) + } + (_, _, _) => unreachable!(), + } + } +} + +impl + Clone> ModularUnaryOps<&Self> for Mint { + type Output = Self; + #[inline] + fn negm(self, m: &Self) -> Self::Output { + Self(Right(match (self.0, &m.0) { + (Left(v), Left(m)) => ReducedInt::new(v, m).neg(), + (Right(v), Left(m)) => { + debug_assert!(&v.modulus() == m); + v.neg() + } + (_, Right(_)) => unreachable!(), + })) + } + fn invm(self, _: &Self) -> Option { + unreachable!() // not used in this crate + } + #[inline] + fn dblm(self, m: &Self) -> Self::Output { + Self(Right(match (self.0, &m.0) { + (Left(v), Left(m)) => ReducedInt::new(v, m).double(), + (Right(v), Left(m)) => { + debug_assert!(&v.modulus() == m); + v.double() + } + (_, Right(_)) => unreachable!(), + })) + } + #[inline] + fn sqm(self, m: &Self) -> Self::Output { + Self(Right(match (self.0, &m.0) { + (Left(v), Left(m)) => ReducedInt::new(v, m).square(), + (Right(v), Left(m)) => { + debug_assert!(&v.modulus() == m); + v.square() + } + (_, Right(_)) => unreachable!(), + })) + } +} +impl + Clone> ModularUnaryOps<&Mint> for &Mint { + type Output = Mint; + #[inline] + fn negm(self, m: &Mint) -> Self::Output { + Mint(Right(match (&self.0, &m.0) { + (Left(v), Left(m)) => ReducedInt::new(v.clone(), m).neg(), + (Right(v), Left(m)) => { + debug_assert!(&v.modulus() == m); + v.clone().neg() + } + (_, Right(_)) => unreachable!(), + })) + } + fn invm(self, _: &Mint) -> Option { + unreachable!() // not used in this crate + } + #[inline] + fn dblm(self, m: &Mint) -> Self::Output { + Mint(Right(match (&self.0, &m.0) { + (Left(v), Left(m)) => ReducedInt::new(v.clone(), m).double(), + (Right(v), Left(m)) => { + debug_assert!(&v.modulus() == m); + v.clone().double() + } + (_, Right(_)) => unreachable!(), + })) + } + #[inline] + fn sqm(self, m: &Mint) -> Self::Output { + Mint(Right(match (&self.0, &m.0) { + (Left(v), Left(m)) => ReducedInt::new(v.clone(), m).square(), + (Right(v), Left(m)) => { + debug_assert!(&v.modulus() == m); + v.clone().square() + } + (_, Right(_)) => unreachable!(), + })) + } +} + +impl ModularSymbols<&'r T>, R: Reducer + Clone> + ModularSymbols<&Self> for Mint +{ + #[inline] + fn checked_jacobi(&self, n: &Self) -> Option { + match (&self.0, &n.0) { + (Left(a), Left(n)) => a.checked_jacobi(n), + (Right(a), Left(n)) => a.residue().checked_jacobi(n), + (_, Right(_)) => unreachable!(), + } + } + #[inline] + fn checked_legendre(&self, n: &Self) -> Option { + match (&self.0, &n.0) { + (Left(a), Left(n)) => a.checked_legendre(n), + (Right(a), Left(n)) => a.residue().checked_legendre(n), + (_, Right(_)) => unreachable!(), + } + } + #[inline] + fn kronecker(&self, n: &Self) -> i8 { + match (&self.0, &n.0) { + (Left(a), Left(n)) => a.kronecker(n), + (Right(a), Left(n)) => a.residue().kronecker(n), + (_, Right(_)) => unreachable!(), + } + } +} + +impl + Clone> ModularPow<&Self, &Self> for Mint { + type Output = Self; + #[inline] + fn powm(self, exp: &Self, m: &Self) -> Self::Output { + Self(Right(match (self.0, &exp.0, &m.0) { + (Left(v), Left(e), Left(m)) => ReducedInt::new(v, m).pow(&e.clone()), + (Right(v), Left(e), Left(m)) => { + debug_assert!(&v.modulus() == m); + v.pow(&e.clone()) + } + (_, _, _) => unreachable!(), + })) + } +} + +pub type SmallMint = Mint>; + +#[cfg(test)] +#[allow(clippy::op_ref)] +mod tests { + use super::*; + + #[test] + fn test_basics() { + let a: SmallMint = 19.into(); + let b: SmallMint = 8.into(); + assert_eq!(a + b, 27.into()); + } + + // --- Sub, Mul, Div, Rem operators --- + #[test] + fn test_sub() { + let a: SmallMint = 19.into(); + let b: SmallMint = 8.into(); + assert_eq!(a - b, SmallMint::from(11u32)); + // ref variants + let a: SmallMint = 19.into(); + let b: SmallMint = 8.into(); + assert_eq!(&a - &b, SmallMint::from(11u32)); + assert_eq!(&a - b, SmallMint::from(11u32)); + let b2: SmallMint = 8.into(); + assert_eq!(a - &b2, SmallMint::from(11u32)); + } + + #[test] + fn test_mul() { + let a: SmallMint = 7.into(); + let b: SmallMint = 6.into(); + assert_eq!(a * b, SmallMint::from(42u32)); + let a: SmallMint = 7.into(); + let b: SmallMint = 6.into(); + assert_eq!(&a * &b, SmallMint::from(42u32)); + } + + #[test] + fn test_div() { + let a: SmallMint = 42.into(); + let b: SmallMint = 7.into(); + assert_eq!(a / b, SmallMint::from(6u32)); + // ref variants + let a: SmallMint = 42.into(); + let b: SmallMint = 7.into(); + assert_eq!(&a / &b, SmallMint::from(6u32)); + assert_eq!(&a / b, SmallMint::from(6u32)); + let b2: SmallMint = 7.into(); + assert_eq!(a / &b2, SmallMint::from(6u32)); + } + + #[test] + fn test_rem_creates_right_variant() { + let a: SmallMint = 19.into(); + let m: SmallMint = 7.into(); + let r = a % m; // creates Right variant (ReducedInt) + assert_eq!(r.value(), 5); + // ref variants + let a: SmallMint = 19.into(); + let m: SmallMint = 7.into(); + assert_eq!((&a % &m).value(), 5); + assert_eq!((&a % m).value(), 5); + let m2: SmallMint = 7.into(); + assert_eq!((a % &m2).value(), 5); + } + + // --- Zero / One --- + #[test] + fn test_zero_one() { + let z: SmallMint = Zero::zero(); + assert!(z.is_zero()); + assert!(!SmallMint::from(1u32).is_zero()); + + let o: SmallMint = One::one(); + assert!(o.is_one()); + assert!(!SmallMint::from(2u32).is_one()); + } + + // --- Num::from_str_radix --- + #[test] + fn test_from_str_radix() { + let v: SmallMint = Num::from_str_radix("ff", 16).unwrap(); + assert_eq!(v, SmallMint::from(255u32)); + let v: SmallMint = Num::from_str_radix("42", 10).unwrap(); + assert_eq!(v, SmallMint::from(42u32)); + } + + // --- Integer methods --- + #[test] + fn test_integer_methods() { + let a: SmallMint = 17.into(); + let b: SmallMint = 5.into(); + + assert_eq!(a.div_floor(&b), SmallMint::from(3u32)); + assert_eq!(a.mod_floor(&b), SmallMint::from(2u32)); + assert_eq!(a.gcd(&b), SmallMint::from(1u32)); + assert_eq!(a.lcm(&b), SmallMint::from(85u32)); + + let (q, r) = a.div_rem(&b); + assert_eq!(q, SmallMint::from(3u32)); + assert_eq!(r, SmallMint::from(2u32)); + + assert!(!SmallMint::from(7u32).is_even()); + assert!(SmallMint::from(8u32).is_even()); + assert!(SmallMint::from(7u32).is_odd()); + assert!(!SmallMint::from(8u32).is_odd()); + + assert!(SmallMint::from(15u32).is_multiple_of(&SmallMint::from(5u32))); + assert!(!SmallMint::from(14u32).is_multiple_of(&SmallMint::from(5u32))); + } + + // --- Ord / PartialOrd --- + #[test] + fn test_ord() { + let a: SmallMint = 10.into(); + let b: SmallMint = 20.into(); + assert!(a < b); + assert!(b > a); + assert_eq!(a.cmp(&a), std::cmp::Ordering::Equal); + } + + #[test] + fn test_ord_mixed_variants() { + // Left vs Right and Right vs Left + let left: SmallMint = 5.into(); + let val: SmallMint = 12.into(); + let modulus: SmallMint = 7.into(); + let right = val % modulus; // Right variant, residue = 5 + assert_eq!(left.cmp(&right), std::cmp::Ordering::Equal); + assert_eq!(right.cmp(&left), std::cmp::Ordering::Equal); + } + + // --- FromPrimitive --- + #[test] + fn test_from_primitive() { + let v: SmallMint = FromPrimitive::from_u64(42).unwrap(); + assert_eq!(v, SmallMint::from(42u64)); + + let v: SmallMint = FromPrimitive::from_i64(42).unwrap(); + assert_eq!(v, SmallMint::from(42u64)); + + let v: SmallMint = FromPrimitive::from_f64(42.0).unwrap(); + assert_eq!(v, SmallMint::from(42u64)); + } + + // --- ToPrimitive --- + #[test] + fn test_to_primitive_left() { + let v: SmallMint = 42.into(); + assert_eq!(v.to_u64(), Some(42)); + assert_eq!(v.to_i64(), Some(42)); + assert_eq!(v.to_f64(), Some(42.0)); + } + + #[test] + fn test_to_primitive_right() { + // Right variant (after modular reduction) + let v: SmallMint = 19.into(); + let m: SmallMint = 7.into(); + let r = v % m; // Right variant, residue = 5 + assert_eq!(r.to_u64(), Some(5)); + assert_eq!(r.to_i64(), Some(5)); + assert_eq!(r.to_f64(), Some(5.0)); + } + + // --- Pow --- + #[test] + fn test_pow() { + let v: SmallMint = 3.into(); + let result: SmallMint = Pow::pow(v, 4u32); + assert_eq!(result, SmallMint::from(81u64)); + } + + // --- BitTest --- + #[test] + fn test_bittest() { + let v: SmallMint = 0b1010u64.into(); + assert!(v.bit(1)); + assert!(!v.bit(0)); + assert!(v.bit(3)); + assert_eq!(v.bits(), 4); + assert_eq!(v.trailing_zeros(), 1); + } + + // --- Shr --- + #[test] + fn test_shr() { + let v: SmallMint = 16.into(); + assert_eq!(v >> 2, SmallMint::from(4u64)); + // ref variant + let v: SmallMint = 16.into(); + assert_eq!(&v >> 2, SmallMint::from(4u64)); + } + + // --- Roots --- + #[test] + fn test_nth_root() { + let v: SmallMint = 27.into(); + assert_eq!(v.nth_root(3), SmallMint::from(3u64)); + } + + // --- ExactRoots --- + #[test] + fn test_nth_root_exact() { + let v: SmallMint = 49.into(); + assert_eq!(v.nth_root_exact(2).map(|v| v.value()), Some(7)); + let v: SmallMint = 50.into(); + assert!(v.nth_root_exact(2).is_none()); + } + + // --- value() on Left and Right variants --- + #[test] + fn test_value_left() { + let v: SmallMint = 42.into(); + assert_eq!(v.value(), 42); + } + + #[test] + fn test_value_right() { + let v: SmallMint = 19.into(); + let m: SmallMint = 7.into(); + let r = v % m; + assert_eq!(r.value(), 5); + } + + // --- Modular ops (addm, subm, mulm, negm, dblm, sqm, powm) --- + #[test] + fn test_modular_addm() { + use num_modular::ModularCoreOps; + let m: SmallMint = 7.into(); + let a = SmallMint::from(5u32) % &m; + let b = SmallMint::from(4u32) % &m; + let result = a.addm(&b, &m); + assert_eq!(result.value(), 2); // (5+4) % 7 = 2 + } + + #[test] + fn test_modular_addm_ref() { + use num_modular::ModularCoreOps; + let m: SmallMint = 7.into(); + let a = SmallMint::from(5u32) % &m; + let b = SmallMint::from(4u32) % &m; + let result = (&a).addm(&b, &m); + assert_eq!(result.value(), 2); + } + + #[test] + fn test_modular_subm() { + use num_modular::ModularCoreOps; + let m: SmallMint = 7.into(); + let a = SmallMint::from(3u32) % &m; + let b = SmallMint::from(5u32) % &m; + let result = a.subm(&b, &m); + assert_eq!(result.value(), 5); // (3-5) % 7 = 5 + } + + #[test] + fn test_modular_subm_ref() { + use num_modular::ModularCoreOps; + let m: SmallMint = 7.into(); + let a = SmallMint::from(3u32) % &m; + let b = SmallMint::from(5u32) % &m; + let result = (&a).subm(&b, &m); + assert_eq!(result.value(), 5); + } + + #[test] + fn test_modular_mulm() { + use num_modular::ModularCoreOps; + let m: SmallMint = 7.into(); + let a = SmallMint::from(5u32) % &m; + let b = SmallMint::from(4u32) % &m; + let result = a.mulm(&b, &m); + assert_eq!(result.value(), 6); // (5*4) % 7 = 20 % 7 = 6 + } + + #[test] + fn test_modular_mulm_ref() { + use num_modular::ModularCoreOps; + let m: SmallMint = 7.into(); + let a = SmallMint::from(5u32) % &m; + let b = SmallMint::from(4u32) % &m; + let result = (&a).mulm(&b, &m); + assert_eq!(result.value(), 6); + } + + #[test] + fn test_modular_negm() { + use num_modular::ModularUnaryOps; + let m: SmallMint = 7.into(); + // From Left variant + let a: SmallMint = 3.into(); + let result = a.negm(&m); + assert_eq!(result.value(), 4); // -3 % 7 = 4 + // From Right variant + let m: SmallMint = 7.into(); + let a = SmallMint::from(3u32) % &m; + let result = a.negm(&m); + assert_eq!(result.value(), 4); + } + + #[test] + fn test_modular_negm_ref() { + use num_modular::ModularUnaryOps; + let m: SmallMint = 7.into(); + let a: SmallMint = 3.into(); + let result = (&a).negm(&m); + assert_eq!(result.value(), 4); + // Right variant ref + let a = SmallMint::from(3u32) % &m; + let result = (&a).negm(&m); + assert_eq!(result.value(), 4); + } + + #[test] + fn test_modular_dblm() { + use num_modular::ModularUnaryOps; + let m: SmallMint = 7.into(); + let a: SmallMint = 5.into(); + let result = a.dblm(&m); + assert_eq!(result.value(), 3); // (5*2) % 7 = 3 + // Right variant + let m: SmallMint = 7.into(); + let a = SmallMint::from(5u32) % &m; + let result = a.dblm(&m); + assert_eq!(result.value(), 3); + } + + #[test] + fn test_modular_dblm_ref() { + use num_modular::ModularUnaryOps; + let m: SmallMint = 7.into(); + let a: SmallMint = 5.into(); + let result = (&a).dblm(&m); + assert_eq!(result.value(), 3); + let a = SmallMint::from(5u32) % &m; + let result = (&a).dblm(&m); + assert_eq!(result.value(), 3); + } + + #[test] + fn test_modular_sqm() { + use num_modular::ModularUnaryOps; + let m: SmallMint = 7.into(); + let a: SmallMint = 4.into(); + let result = a.sqm(&m); + assert_eq!(result.value(), 2); // (4^2) % 7 = 16 % 7 = 2 + // Right variant + let m: SmallMint = 7.into(); + let a = SmallMint::from(4u32) % &m; + let result = a.sqm(&m); + assert_eq!(result.value(), 2); + } + + #[test] + fn test_modular_sqm_ref() { + use num_modular::ModularUnaryOps; + let m: SmallMint = 7.into(); + let a: SmallMint = 4.into(); + let result = (&a).sqm(&m); + assert_eq!(result.value(), 2); + let a = SmallMint::from(4u32) % &m; + let result = (&a).sqm(&m); + assert_eq!(result.value(), 2); + } + + #[test] + fn test_modular_powm() { + use num_modular::ModularPow; + let m: SmallMint = 7.into(); + // Left variant + let base: SmallMint = 3.into(); + let exp: SmallMint = 4.into(); + let result = base.powm(&exp, &m); + assert_eq!(result.value(), 4); // 3^4 % 7 = 81 % 7 = 4 + // Right variant + let base = SmallMint::from(3u32) % &m; + let result = base.powm(&exp, &m); + assert_eq!(result.value(), 4); + } + + // --- ModularSymbols (jacobi, kronecker) --- + #[test] + fn test_jacobi() { + use num_modular::ModularSymbols; + let a: SmallMint = 2.into(); + let n: SmallMint = 7.into(); + assert_eq!(a.checked_jacobi(&n), Some(1)); // 2 is QR mod 7 + let a: SmallMint = 3.into(); + assert_eq!(a.checked_jacobi(&n), Some(-1)); // 3 is QNR mod 7 + } + + #[test] + fn test_jacobi_right_variant() { + use num_modular::ModularSymbols; + let n: SmallMint = 7.into(); + let a = SmallMint::from(2u64) % &n; // Right variant + assert_eq!(a.checked_jacobi(&n), Some(1)); + } + + #[test] + fn test_kronecker() { + use num_modular::ModularSymbols; + let a: SmallMint = 2.into(); + let n: SmallMint = 7.into(); + assert_eq!(a.kronecker(&n), 1); + } + + #[test] + fn test_kronecker_right_variant() { + use num_modular::ModularSymbols; + let n: SmallMint = 7.into(); + let a = SmallMint::from(2u64) % &n; + assert_eq!(a.kronecker(&n), 1); + } + + #[test] + fn test_legendre() { + use num_modular::ModularSymbols; + let a: SmallMint = 2.into(); + let n: SmallMint = 7.into(); + assert_eq!(a.checked_legendre(&n), Some(1)); + } + + #[test] + fn test_legendre_right_variant() { + use num_modular::ModularSymbols; + let n: SmallMint = 7.into(); + let a = SmallMint::from(3u64) % &n; + assert_eq!(a.checked_legendre(&n), Some(-1)); + } + + // --- is_zero on Right variant --- + #[test] + fn test_is_zero_right_variant() { + let m: SmallMint = 7.into(); + let a = SmallMint::from(7u32) % &m; + assert!(a.is_zero()); + let b = SmallMint::from(3u32) % &m; + assert!(!b.is_zero()); + } + + // --- is_one on Right variant --- + #[test] + fn test_is_one_right_variant() { + let m: SmallMint = 7.into(); + let a = SmallMint::from(8u32) % &m; + assert!(a.is_one()); + } + + // --- is_even/is_odd on Right variant --- + #[test] + fn test_even_odd_right_variant() { + let m: SmallMint = 7.into(); + let a = SmallMint::from(9u32) % &m; // residue 2 + assert!(a.is_even()); + assert!(!a.is_odd()); + } + + // --- Add/Sub/Mul with Right variants --- + #[test] + fn test_add_right_right() { + let m: SmallMint = 7.into(); + let a = SmallMint::from(3u32) % &m; + let b = SmallMint::from(5u32) % &m; + let result = a + b; + assert_eq!(result.value(), 1); // (3+5) % 7 = 1 + } + + #[test] + fn test_add_left_right() { + let m: SmallMint = 7.into(); + let a: SmallMint = 3.into(); + let b = SmallMint::from(5u32) % &m; + let result = a + b; + assert_eq!(result.value(), 1); + } + + #[test] + fn test_add_right_left() { + let m: SmallMint = 7.into(); + let a = SmallMint::from(3u32) % &m; + let b: SmallMint = 5.into(); + let result = a + b; + assert_eq!(result.value(), 1); + } + + #[test] + fn test_sub_right_right() { + let m: SmallMint = 7.into(); + let a = SmallMint::from(5u32) % &m; + let b = SmallMint::from(3u32) % &m; + let result = a - b; + assert_eq!(result.value(), 2); + } + + #[test] + fn test_mul_right_right() { + let m: SmallMint = 7.into(); + let a = SmallMint::from(3u32) % &m; + let b = SmallMint::from(4u32) % &m; + let result = a * b; + assert_eq!(result.value(), 5); // (3*4) % 7 = 12 % 7 = 5 + } + + // --- gcd with Right variants --- + #[test] + fn test_gcd_right_left() { + let m: SmallMint = 7.into(); + let a = SmallMint::from(6u32) % &m; // Right, residue=6 + let b: SmallMint = 3.into(); + assert_eq!(a.gcd(&b), SmallMint::from(3u32)); + } + + #[test] + fn test_gcd_left_right() { + let m: SmallMint = 7.into(); + let a: SmallMint = 6.into(); + let b = SmallMint::from(9u32) % &m; // Right, residue=2 + assert_eq!(a.gcd(&b), SmallMint::from(2u32)); + } + + #[test] + fn test_gcd_right_right() { + let m: SmallMint = 7.into(); + let a = SmallMint::from(6u32) % &m; + let b = SmallMint::from(9u32) % &m; // residue=2 + assert_eq!(a.gcd(&b), SmallMint::from(2u32)); + } + + // --- Rem where Right already matches modulus --- + #[test] + fn test_rem_right_left_same_modulus() { + let m: SmallMint = 7.into(); + let a = SmallMint::from(19u32) % &m; // Right variant + let result = a % m; // Right % Left with matching modulus + assert_eq!(result.value(), 5); + } +} diff --git a/vendor/num-prime/src/montgomery.rs b/vendor/num-prime/src/montgomery.rs new file mode 100644 index 0000000..be0b614 --- /dev/null +++ b/vendor/num-prime/src/montgomery.rs @@ -0,0 +1,492 @@ +//! Pollard's rho over Montgomery arithmetic for arbitrary-precision integers. +//! +//! The generic [`pollard_rho`][crate::factor::pollard_rho] reduces through +//! [`ModularCoreOps`][num_modular::ModularCoreOps], which for [`BigUint`] means +//! a full division per modular multiplication. Keeping the modulus in +//! Montgomery form instead removes those divisions, which is worth roughly a +//! factor of five on the numbers where rho actually spends its time. + +use core::cmp::Ordering; + +use num_bigint::BigUint; +use num_integer::Integer; +use num_traits::{FromPrimitive, One}; + +use crate::traits::BitTest; + +/// Montgomery arithmetic modulo an odd `n`, held as little-endian 64-bit limbs. +/// +/// Values are plain residues in `[0, n)`; [`Montgomery::mulredc`] computes +/// `lhs * rhs * R^-1 mod n` rather than `lhs * rhs mod n`. Pollard's rho does +/// not care: the iteration stays a pseudo-random map, and the extra powers of +/// `R^-1` accumulated in the gcd product are units modulo `n`. +struct Montgomery { + n: Vec, + /// `-n^-1 mod 2^64` + n0inv: u64, +} + +/// `x^-1 mod 2^64`, for odd `x`, by Newton's iteration. +fn binv(x: u64) -> u64 { + // x is its own inverse modulo 8, and each step doubles the correct bits. + let mut y = x; + for _ in 0..5 { + y = y.wrapping_mul(2u64.wrapping_sub(x.wrapping_mul(y))); + } + y +} + +fn to_limbs(x: &BigUint, len: usize) -> Vec { + let mut limbs: Vec = x.iter_u64_digits().collect(); + limbs.resize(len, 0); + limbs +} + +fn from_limbs(limbs: &[u64]) -> BigUint { + let mut bytes = Vec::with_capacity(limbs.len() * 8); + for limb in limbs { + bytes.extend_from_slice(&limb.to_le_bytes()); + } + BigUint::from_bytes_le(&bytes) +} + +impl Montgomery { + /// `n` must be odd and larger than one. + fn new(n: &BigUint) -> Self { + let n: Vec = n.iter_u64_digits().collect(); + let n0inv = binv(n[0]).wrapping_neg(); + Montgomery { n, n0inv } + } + + fn len(&self) -> usize { + self.n.len() + } + + /// Whether `x`, extended with `high` as its most significant limb, is `>= n`. + fn geq(&self, x: &[u64], high: u64) -> bool { + if high != 0 { + return true; + } + for (a, b) in x.iter().zip(&self.n).rev() { + match a.cmp(b) { + Ordering::Equal => (), + other => return other == Ordering::Greater, + } + } + true + } + + /// `x -= n`, dropping the borrow out of the most significant limb. + fn sub_n(&self, x: &mut [u64]) { + let mut borrow = 0u64; + for (a, b) in x.iter_mut().zip(&self.n) { + let (d, b1) = a.overflowing_sub(*b); + let (d, b2) = d.overflowing_sub(borrow); + *a = d; + borrow = (b1 | b2) as u64; + } + } + + /// `out = lhs * rhs * R^-1 mod n`, by the CIOS variant of Montgomery + /// multiplication. `acc` is scratch space of `n.len() + 2` limbs. + fn mulredc(&self, lhs: &[u64], rhs: &[u64], out: &mut [u64], acc: &mut [u64]) { + let len = self.len(); + for limb in acc.iter_mut() { + *limb = 0; + } + + for &rhs_i in &rhs[..len] { + let rhs_i = rhs_i as u128; + let mut carry = 0u128; + for j in 0..len { + let cur = acc[j] as u128 + lhs[j] as u128 * rhs_i + carry; + acc[j] = cur as u64; + carry = cur >> 64; + } + let cur = acc[len] as u128 + carry; + acc[len] = cur as u64; + acc[len + 1] = (cur >> 64) as u64; + + let quot = acc[0].wrapping_mul(self.n0inv) as u128; + // The low limb of acc[0] + quot * n[0] is zero by construction of quot. + let mut carry = (acc[0] as u128 + quot * self.n[0] as u128) >> 64; + for j in 1..len { + let cur = acc[j] as u128 + quot * self.n[j] as u128 + carry; + acc[j - 1] = cur as u64; + carry = cur >> 64; + } + let cur = acc[len] as u128 + carry; + acc[len - 1] = cur as u64; + acc[len] = acc[len + 1] + (cur >> 64) as u64; + } + + out.copy_from_slice(&acc[..len]); + // With lhs, rhs < n the CIOS result is below 2n, so one subtraction + // normalizes it. + if self.geq(out, acc[len]) { + self.sub_n(out); + } + } + + /// `x = x + c mod n`, for `c` smaller than `n`. + fn addc(&self, x: &mut [u64], c: u64) { + let mut carry = c as u128; + for limb in x.iter_mut() { + let cur = *limb as u128 + carry; + *limb = cur as u64; + carry = cur >> 64; + } + if self.geq(x, carry as u64) { + self.sub_n(x); + } + } + + /// `out = lhs + rhs mod n`. + fn add(&self, lhs: &[u64], rhs: &[u64], out: &mut [u64]) { + let mut carry = 0u128; + for (i, out_i) in out.iter_mut().enumerate() { + let cur = lhs[i] as u128 + rhs[i] as u128 + carry; + *out_i = cur as u64; + carry = cur >> 64; + } + if self.geq(out, carry as u64) { + self.sub_n(out); + } + } + + /// `out = lhs - rhs mod n`. + fn sub(&self, lhs: &[u64], rhs: &[u64], out: &mut [u64]) { + let mut borrow = 0u64; + for (i, out_i) in out.iter_mut().enumerate() { + let (diff, borrow1) = lhs[i].overflowing_sub(rhs[i]); + let (diff, borrow2) = diff.overflowing_sub(borrow); + *out_i = diff; + borrow = (borrow1 | borrow2) as u64; + } + if borrow != 0 { + let mut carry = 0u128; + for (out_i, n_i) in out.iter_mut().zip(&self.n) { + let cur = *out_i as u128 + *n_i as u128 + carry; + *out_i = cur as u64; + carry = cur >> 64; + } + } + } +} + +/// Find a non-trivial divisor of the odd composite `n` with Pollard's rho. +/// +/// `n` must be odd, larger than one, composite, and not a perfect power; +/// [`divisor`] establishes all of that. The search is unbounded: rho will +/// always split such an `n` eventually, so the only question is how long it +/// takes. +/// +/// Floyd's cycle detection over `x -> x^2 + c`, with the differences +/// accumulated into a product so that a single gcd covers a whole batch of +/// them. Keeping the last non-zero product rather than the current one is what +/// makes that batch safe: the accumulator never reaches zero, so `gcd(prod, n)` +/// can never be `n`, and a gcd that is not one is already a proper divisor -- +/// there is no batch to replay and no failure to recover from. The tortoise +/// catching the hare means the sequence cycled without splitting `n`, so `c` +/// moves on to the next polynomial. +/// +/// Modelled on KACTL's `content/number-theory/Factor.h` (CC0-1.0), specialized +/// to Montgomery arithmetic and to a gcd over [`BigUint`]. +fn pollard_rho(n: &BigUint) -> BigUint { + rho(n).0 +} + +/// [`pollard_rho`], also reporting the polynomial constant that split `n`. +/// +/// Only the divisor is of interest in anger; the tests use `c` to tell a split +/// found under the opening polynomial from one that needed a later. +fn rho(n: &BigUint) -> (BigUint, u64) { + /// Differences accumulated into `prod` per gcd. A bigger batch trades + /// steps wasted past the split for fewer of the gcds, which dominate. + const BATCH: usize = 128; + + let mont = Montgomery::new(n); + let len = mont.len(); + let mut scratch = vec![0u64; len + 2]; + // 1 in Montgomery form, i.e. R mod n. + let one = to_limbs(&((BigUint::one() << (64 * len)) % n), len); + + let mut diff = vec![0u64; len]; + let mut next = vec![0u64; len]; + + // Both walkers start at 2 in Montgomery form; prod accumulates the + // differences whose gcd with n is taken once per batch. + let mut tortoise = vec![0u64; len]; + mont.add(&one, &one, &mut tortoise); + let start = tortoise.clone(); + let mut hare = tortoise.clone(); + let mut prod = one; + + // Both walkers start equal, so the opening pass through the cycled branch + // below is what picks the first polynomial: c is a "none yet" sentinel + // until then. It starts at 1 rather than 0 because x^2 + 2 opens better + // than x^2 + 1 -- ~35% on the hard factorization benchmarks. + let mut c = 1u64; + let mut steps = 0usize; + loop { + if tortoise == hare { + // The sequence cycled without splitting n: start over from the + // same point under the next polynomial, keeping what prod holds. + c += 1; + tortoise.copy_from_slice(&start); + hare.copy_from_slice(&start); + } + + mont.sub(&tortoise, &hare, &mut diff); + mont.mulredc(&prod, &diff, &mut next, &mut scratch); + if next.iter().any(|&limb| limb != 0) { + prod.copy_from_slice(&next); + } + + // The tortoise takes one step, the hare two. + mont.mulredc(&tortoise, &tortoise, &mut next, &mut scratch); + core::mem::swap(&mut tortoise, &mut next); + mont.addc(&mut tortoise, c); + for _ in 0..2 { + mont.mulredc(&hare, &hare, &mut next, &mut scratch); + core::mem::swap(&mut hare, &mut next); + mont.addc(&mut hare, c); + } + + steps += 1; + if steps == BATCH { + steps = 0; + let gcd = from_limbs(&prod).gcd(n); + if !gcd.is_one() { + return (gcd, c); + } + } + } +} + +/// If `x` is a perfect power, return its root and the exponent. +/// +/// Pollard's rho needs about `sqrt(p)` iterations to split `p^k`, which is +/// hopeless for a large `p`, so these are peeled off beforehand. +fn perfect_power(x: &BigUint) -> Option<(BigUint, u32)> { + let bits = x.bits() as u32; + for e in 2..=bits { + // A perfect power is a perfect power for a prime exponent too. + if (2..).take_while(|d| d * d <= e).any(|d| e % d == 0) { + continue; + } + let root = x.nth_root(e); + if root.is_one() { + break; + } + if root.pow(e) == *x { + return Some((root, e)); + } + } + None +} + +/// Widen an arbitrary integer into a [`BigUint`], bit by bit. +/// +/// This is only ever called on targets that do not fit in a `u128`, where the +/// cost is negligible next to the factorization that follows. +pub(crate) fn to_biguint(x: &T) -> BigUint { + let mut bytes = vec![0u8; (x.bits() + 7) / 8]; + for i in 0..x.bits() { + if x.bit(i) { + bytes[i / 8] |= 1 << (i % 8); + } + } + BigUint::from_bytes_le(&bytes) +} + +/// Narrow a [`BigUint`] back into the caller's integer type. +pub(crate) fn from_biguint(x: &BigUint) -> T { + let shift = T::from_u64(1 << 32).unwrap(); + let mut acc = T::zero(); + for digit in x.iter_u32_digits().rev() { + acc = acc * shift.clone() + T::from_u32(digit).unwrap(); + } + acc +} + +/// A non-trivial divisor of the odd composite `n`, or the factorization of a +/// perfect power as `(root, exponent)`. +pub(crate) enum Split { + Divisor(BigUint), + Power(BigUint, u32), +} + +/// Split the odd composite `n`, which must be larger than `u128::MAX`. +pub(crate) fn divisor(n: &BigUint) -> Split { + match perfect_power(n) { + Some((root, exp)) => Split::Power(root, exp), + None => Split::Divisor(pollard_rho(n)), + } +} + +#[cfg(test)] +mod tests { + use super::*; + use num_traits::Zero; + + fn parse(s: &str) -> BigUint { + s.parse().unwrap() + } + + fn check_divisor(s: &str) -> BigUint { + let n = parse(s); + match divisor(&n) { + Split::Divisor(d) => { + assert!(d > BigUint::one(), "trivial divisor of {}", n); + assert!(d < n, "trivial divisor of {}", n); + assert!((&n % &d).is_zero(), "{} does not divide {}", d, n); + d + } + Split::Power(root, exp) => panic!("unexpected perfect power {}^{}", root, exp), + } + } + + /// The point of keeping the last non-zero product: when Floyd's walkers + /// meet without having split `n`, the polynomial constant advances and the + /// walk restarts, carrying `prod` over. Only small moduli cycle soon + /// enough to reach that branch -- the wide ones this module is built for + /// split long before their sequences close. + #[test] + fn advances_the_polynomial_when_the_sequence_cycles() { + for n in [35u64, 1_000_025, 1_000_027] { + let big = BigUint::from(n); + let (d, c) = rho(&big); + assert!(c > 2, "{} split under the opening polynomial", n); + assert!( + d > BigUint::one() && d < big, + "trivial divisor {} of {}", + d, + n + ); + assert!((&big % &d).is_zero(), "{} does not divide {}", d, n); + } + } + + /// The counterpart: a modulus of the size this module actually sees splits + /// under the opening polynomial, without ever taking that branch. + #[test] + fn a_wide_semiprime_splits_under_the_opening_polynomial() { + let (_, c) = rho(&parse("1180591625390335725871")); + assert_eq!(c, 2); + } + + #[test] + fn binv_inverts_odd_words() { + for x in [1u64, 3, 5, 0xffff_ffff_ffff_ffff, 0x9e37_79b9_7f4a_7c15] { + assert_eq!(x.wrapping_mul(binv(x)), 1); + } + } + + #[test] + fn limb_roundtrip() { + let n = parse("340282366920938463463374607431768211507"); + assert_eq!(from_limbs(&to_limbs(&n, 4)), n); + } + + #[test] + fn biguint_roundtrip() { + let n = parse("340282366920938463463374607431768211507"); + assert_eq!(to_biguint(&n), n); + assert_eq!(from_biguint::(&n), n); + let narrow: u128 = 340_282_366_920_938_463_463_374_607_431_768_211_455; + assert_eq!(to_biguint(&narrow), BigUint::from(narrow)); + assert_eq!(from_biguint::(&BigUint::from(narrow)), narrow); + } + + #[test] + fn mulredc_matches_plain_arithmetic() { + let n = parse("340282366920938463463374607431768211507"); + let mont = Montgomery::new(&n); + let len = mont.len(); + let r = (BigUint::one() << (64 * len)) % &n; + let r_inv = { + // R^-1 mod n, by Fermat's little theorem (n is prime here). + r.modpow(&(&n - BigUint::from(2u32)), &n) + }; + let mut scratch = vec![0u64; len + 2]; + let mut out = vec![0u64; len]; + for (a, b) in [("2", "3"), ("123456789", "987654321"), ("0", "7")] { + let (a, b) = (parse(a) % &n, parse(b) % &n); + mont.mulredc( + &to_limbs(&a, len), + &to_limbs(&b, len), + &mut out, + &mut scratch, + ); + assert_eq!(from_limbs(&out), (&a * &b * &r_inv) % &n, "{} * {}", a, b); + } + } + + #[test] + fn add_sub_wrap_around_the_modulus() { + let n = parse("340282366920938463463374607431768211507"); + let mont = Montgomery::new(&n); + let len = mont.len(); + let a = &n - BigUint::from(1u32); + let b = BigUint::from(5u32); + let mut out = vec![0u64; len]; + + mont.add(&to_limbs(&a, len), &to_limbs(&b, len), &mut out); + assert_eq!(from_limbs(&out), (&a + &b) % &n); + + mont.sub(&to_limbs(&b, len), &to_limbs(&a, len), &mut out); + assert_eq!(from_limbs(&out), (&b + &n - &a) % &n); + + let mut x = to_limbs(&a, len); + mont.addc(&mut x, 5); + assert_eq!(from_limbs(&x), (&a + &b) % &n); + } + + #[test] + fn splits_a_semiprime() { + // 34359738421 * 34359738451 + let d = check_divisor("1180591625390335725871"); + assert!(d == parse("34359738421") || d == parse("34359738451")); + } + + #[test] + fn splits_a_product_of_thirteen_similar_primes() { + check_divisor( + "256192672085272469290287843204387360975152374284235599731951768269391636066386517575760286247162035537155995319918598846421204855240141082924971355328149", + ); + } + + #[test] + fn splits_a_square_free_number_with_a_tiny_factor() { + // 3 * (2^127 - 1) -- one factor far smaller than the other + let d = check_divisor("510423550381407695195061911147652317181"); + assert!(d == parse("3") || d == parse("170141183460469231731687303715884105727")); + } + + #[test] + fn detects_perfect_powers() { + // 34359738421^5 + let n = parse("47890486021415120313827563670912728827215402664536101"); + match divisor(&n) { + Split::Power(root, exp) => { + assert_eq!(root, parse("34359738421")); + assert_eq!(exp, 5); + } + Split::Divisor(d) => panic!("expected a perfect power, got {}", d), + } + } + + #[test] + fn detects_a_square_of_a_composite() { + // (34359738421 * 34359738451)^2 + let n = parse("1393796585941794802955558839641240458708641"); + match divisor(&n) { + Split::Power(root, exp) => { + assert_eq!(root, parse("1180591625390335725871")); + assert_eq!(exp, 2); + } + Split::Divisor(d) => panic!("expected a perfect power, got {}", d), + } + } +} diff --git a/vendor/num-prime/src/nt_funcs.rs b/vendor/num-prime/src/nt_funcs.rs new file mode 100644 index 0000000..85127ee --- /dev/null +++ b/vendor/num-prime/src/nt_funcs.rs @@ -0,0 +1,1731 @@ +//! Standalone number theoretic functions +//! +//! The functions in this module can be called without an instance of [`crate::traits::PrimeBuffer`]. +//! However, some functions do internally call the implementation on [`PrimeBufferExt`] +//! (especially those dependent of integer factorization). For these functions, if you have +//! to call them repeatedly, it's recommended to create a [`crate::traits::PrimeBuffer`] +//! instance and use its associated methods for better performance. +//! +//! For number theoretic functions that depends on integer factorization, strongest primality +//! check will be used in factorization, since for these functions we prefer correctness +//! over speed. +//! + +use crate::buffer::{NaiveBuffer, PrimeBufferExt}; +use crate::factor::{one_line, pollard_rho, squfof, SQUFOF_MULTIPLIERS}; +use crate::mint::SmallMint; +use crate::primality::{PrimalityBase, PrimalityRefBase}; +use crate::splitmix64::SplitMix64; +use crate::tables::{ + MOEBIUS_ODD, SMALL_PRIMES, SMALL_PRIMES_NEXT, WHEEL_NEXT, WHEEL_PREV, WHEEL_SIZE, +}; +#[cfg(feature = "big-table")] +use crate::tables::{SMALL_PRIMES_INV, ZETA_LOG_TABLE}; +use crate::traits::{FactorizationConfig, Primality, PrimalityTestConfig, PrimalityUtils}; +use crate::{BitTest, ExactRoots}; +use num_integer::Roots; +#[cfg(feature = "big-table")] +use num_modular::DivExact; +use num_modular::{ModularCoreOps, ModularInteger, MontgomeryInt}; +use num_traits::{CheckedAdd, FromPrimitive, Num, RefNum, ToPrimitive}; +use std::collections::BTreeMap; +use std::convert::TryFrom; + +#[cfg(feature = "big-table")] +use crate::tables::{MILLER_RABIN_BASE32, MILLER_RABIN_BASE64}; + +/// Fast primality test on a u64 integer. It's based on +/// deterministic Miller-rabin tests. If target is larger than 2^64 or more +/// controlled primality tests are desired, please use [is_prime()] +/// +/// # Examples +/// +/// ``` +/// use num_prime::nt_funcs::is_prime64; +/// +/// assert!(is_prime64(2)); +/// assert!(is_prime64(13)); +/// assert!(!is_prime64(1)); +/// assert!(!is_prime64(15)); +/// assert!(is_prime64(6_469_693_333)); +/// ``` +#[cfg(not(feature = "big-table"))] +#[inline] +pub fn is_prime64(target: u64) -> bool { + // shortcuts + if target < 2 { + return false; + } + if target & 1 == 0 { + return target == 2; + } + if let Ok(u) = u8::try_from(target) { + // find in the prime list if the target is small enough + return SMALL_PRIMES.binary_search(&u).is_ok(); + } else { + // check remainder against the wheel table + // this step eliminates any number that is not coprime to WHEEL_SIZE + let pos = (target % WHEEL_SIZE as u64) as usize; + if pos == 0 || WHEEL_NEXT[pos] < WHEEL_NEXT[pos - 1] { + return false; + } + } + + // Then do a deterministic Miller-rabin test + is_prime64_miller(target) +} + +/// Very fast primality test on a u64 integer is a prime number. It's based on +/// deterministic Miller-rabin tests with hashing. if target is larger than 2^64 or more controlled +/// primality tests are desired, please use [`is_prime()`] +/// +/// # Examples +/// +/// ``` +/// use num_prime::nt_funcs::is_prime64; +/// +/// assert!(is_prime64(2)); +/// assert!(is_prime64(13)); +/// assert!(!is_prime64(1)); +/// assert!(!is_prime64(15)); +/// assert!(is_prime64(6_469_693_333)); +/// ``` +#[cfg(feature = "big-table")] +#[inline] +#[must_use] +pub fn is_prime64(target: u64) -> bool { + // shortcuts + if target < 2 { + return false; + } + if target & 1 == 0 { + return target == 2; + } + + // remove small factors + if target < SMALL_PRIMES_NEXT { + // find in the prime list if the target is small enough + return SMALL_PRIMES.binary_search(&(target as u16)).is_ok(); + } else { + // check remainder against the wheel table + // this step eliminates any number that is not coprime to WHEEL_SIZE + let pos = (target % u64::from(WHEEL_SIZE)) as usize; + if pos == 0 || WHEEL_NEXT[pos] < WHEEL_NEXT[pos - 1] { + return false; + } + } + + // Then do a deterministic Miller-rabin test + is_prime64_miller(target) +} + +// Primality test for u64 with only miller-rabin tests, used during factorization. +// It assumes the target is odd, not too small and cannot be divided small primes +#[cfg(not(feature = "big-table"))] +#[inline] +fn is_prime64_miller(target: u64) -> bool { + // The collection of witnesses are from http://miller-rabin.appspot.com/ + if let Ok(u) = u32::try_from(target) { + const WITNESS32: [u32; 3] = [2, 7, 61]; + let u = SmallMint::from(u); + WITNESS32.iter().all(|&x| u.is_sprp(SmallMint::from(x))) + } else { + const WITNESS64: [u64; 7] = [2, 325, 9375, 28178, 450775, 9780504, 1795265022]; + let u = SmallMint::from(target); + WITNESS64.iter().all(|&x| u.is_sprp(SmallMint::from(x))) + } +} + +#[cfg(feature = "big-table")] +#[inline] +fn is_prime32_miller(target: u32) -> bool { + let h = u64::from(target); + let h = ((h >> 16) ^ h).wrapping_mul(0x045d_9f3b); + let h = ((h >> 16) ^ h).wrapping_mul(0x045d_9f3b); + let h = ((h >> 16) ^ h) & 255; + let u = SmallMint::from(target); + u.is_sprp(SmallMint::from(u32::from(MILLER_RABIN_BASE32[h as usize]))) +} + +// Primality test for u64 with only miller-rabin tests, used during factorization. +// It assumes the target is odd, not too small and cannot be divided small primes +#[cfg(feature = "big-table")] +#[inline] +fn is_prime64_miller(target: u64) -> bool { + if let Ok(u) = u32::try_from(target) { + return is_prime32_miller(u); + } + + let u = SmallMint::from(target); + if !u.is_sprp(2.into()) { + return false; + } + + let h = target; + let h = ((h >> 32) ^ h).wrapping_mul(0x045d_9f3b_3335_b369); + let h = ((h >> 32) ^ h).wrapping_mul(0x0333_5b36_945d_9f3b); + let h = ((h >> 32) ^ h) & 16383; + let b = MILLER_RABIN_BASE64[h as usize]; + u.is_sprp((u64::from(b) & 4095).into()) && u.is_sprp((u64::from(b) >> 12).into()) +} + +/// Fast integer factorization on a u64 target. It's based on a selection of factorization methods. +/// if target is larger than 2^128 or more controlled primality tests are desired, please use [`factors()`][crate::buffer::PrimeBufferExt::factors]. +/// +/// The factorization can be quite faster under 2^64 because: 1) faster and deterministic primality check, +/// 2) efficient montgomery multiplication implementation of u64 +/// +/// # Examples +/// +/// ``` +/// use num_prime::nt_funcs::factorize64; +/// use std::collections::BTreeMap; +/// use std::iter::FromIterator; +/// +/// let fac = factorize64(4095); +/// assert_eq!(fac, BTreeMap::from_iter([(3, 2), (5, 1), (7, 1), (13, 1)])); +/// +/// let fac = factorize64(123_456_789); +/// assert_eq!(fac, BTreeMap::from_iter([(3, 2), (3607, 1), (3803, 1)])); +/// ``` +#[must_use] +pub fn factorize64(target: u64) -> BTreeMap { + // TODO: improve factorization performance + // REF: http://flintlib.org/doc/ulong_extras.html#factorisation + // https://mathoverflow.net/questions/114018/fastest-way-to-factor-integers-260 + // https://hal.inria.fr/inria-00188645v3/document + // https://github.com/coreutils/coreutils/blob/master/src/factor.c + // https://github.com/uutils/coreutils/blob/master/src/uu/factor/src/cli.rs + // https://github.com/elmomoilanen/prime-factorization + // https://github.com/radii/msieve + // https://github.com/zademn/facto-rs + // Pari/GP: ifac_crack + let mut result = BTreeMap::new(); + + // quick check on factors of 2 + let f2 = target.trailing_zeros(); + if f2 != 0 { + result.insert(2, f2 as usize); + } + + // trial division using primes in the table + let mut tsqrt = target.sqrt() + 1; + + let mut residual = target >> f2; + let mut factored = false; + + #[cfg(not(feature = "big-table"))] + for p in SMALL_PRIMES.iter().skip(1).map(|&v| v as u64) { + if p > tsqrt { + factored = true; + break; + } + + if residual % p == 0 { + residual /= p; + *result.entry(p).or_insert(0) += 1; + while residual % p == 0 { + residual /= p; + *result.entry(p).or_insert(0) += 1; + } + tsqrt = residual.sqrt() + 1; + } + if residual == 1 { + factored = true; + break; + } + } + + #[cfg(feature = "big-table")] + // divisibility check with pre-computed tables, see comments on SMALL_PRIMES_INV for reference + for (p, &pinv) in SMALL_PRIMES + .iter() + .map(|&p| u64::from(p)) + .zip(SMALL_PRIMES_INV.iter()) + .skip(1) + { + // only need to test primes up to sqrt(target) + if p > tsqrt { + factored = true; + break; + } + + let mut exp: usize = 0; + while let Some(q) = DivExact::div_exact(residual, p, &pinv) { + exp += 1; + residual = q; + } + if exp > 0 { + result.insert(p, exp); + tsqrt = residual.sqrt() + 1; + } + + if residual == 1 { + factored = true; + break; + } + } + + if factored { + if residual != 1 { + result.insert(residual, 1); + } + return result; + } + + // check primality on the residual before expensive factorization + if residual == 1 { + return result; + } + if is_prime64_miller(residual) { + result.insert(residual, 1); + return result; + } + + // then try advanced methods to find a divisor util fully factored + for (p, exp) in factorize64_advanced(&[(residual, 1usize)]) { + *result.entry(p).or_insert(0) += exp; + } + result +} + +// This function factorize all cofactors after some trivial division steps +pub(crate) fn factorize64_advanced(cofactors: &[(u64, usize)]) -> Vec<(u64, usize)> { + let mut todo: Vec<_> = cofactors.to_vec(); + let mut factored: Vec<(u64, usize)> = Vec::with_capacity(cofactors.len() * 2); // prime factor, exponent + + while let Some((target, exp)) = todo.pop() { + if is_prime64_miller(target) { + factored.push((target, exp)); + continue; + } + + // check perfect powers before other methods, this is required for SQUFOF + // it suffices to check square and cubic if big-table is enabled, since fifth power of + // the smallest prime that haven't been checked is 8167^5 > 2^64 + if let Some(d) = target.sqrt_exact() { + todo.push((d, exp * 2)); + continue; + } + if let Some(d) = target.cbrt_exact() { + todo.push((d, exp * 3)); + continue; + } + + // try to find a divisor + let mut i = 0usize; + let mut max_iter_ratio = 1; // increase max_iter after factorization round + let mut rng = SplitMix64::new(target); + let divisor = loop { + // try various factorization method iteratively + const NMETHODS: usize = 3; + match i % NMETHODS { + 0 => { + // Pollard's rho (quick check) + let start = MontgomeryInt::new(rng.next_u64(), &target); + let offset = start.convert(rng.next_u64()); + let max_iter = max_iter_ratio << (target.bits() / 6); // unoptimized heuristic + if let (Some(p), _) = pollard_rho( + &SmallMint::from(target), + start.into(), + offset.into(), + max_iter, + ) { + break p.value(); + } + } + 1 => { + // Hart's one-line (quick check) + let mul_target = target.checked_mul(480).unwrap_or(target); + let max_iter = max_iter_ratio << (mul_target.bits() / 6); // unoptimized heuristic + if let (Some(p), _) = one_line(&target, mul_target, max_iter) { + break p; + } + } + 2 => { + // Shanks's squfof (main power) + let mut d = None; + for &k in &SQUFOF_MULTIPLIERS { + if let Some(mul_target) = target.checked_mul(u64::from(k)) { + let max_iter = max_iter_ratio * 2 * mul_target.sqrt().sqrt() as usize; + if let (Some(p), _) = squfof(&target, mul_target, max_iter) { + d = Some(p); + break; + } + } + } + if let Some(p) = d { + break p; + } + } + _ => unreachable!(), + } + i += 1; + + // increase max iterations after trying all methods + if i % NMETHODS == 0 { + max_iter_ratio *= 2; + } + }; + todo.push((divisor, exp)); + todo.push((target / divisor, exp)); + } + factored +} + +/// Fast integer factorization on a u128 target. It's based on a selection of factorization methods. +/// if target is larger than 2^128 or more controlled primality tests are desired, please use [`factors()`][crate::buffer::PrimeBufferExt::factors]. +/// +/// # Examples +/// +/// ``` +/// use num_prime::nt_funcs::factorize128; +/// use std::collections::BTreeMap; +/// use std::iter::FromIterator; +/// +/// let fac = factorize128(4095); +/// assert_eq!(fac, BTreeMap::from_iter([(3, 2), (5, 1), (7, 1), (13, 1)])); +/// +/// let fac = factorize128(8167u128.pow(3)); +/// assert_eq!(fac, BTreeMap::from_iter([(8167, 3)])); +/// ``` +#[must_use] +pub fn factorize128(target: u128) -> BTreeMap { + // shortcut for u64 + if target < (1u128 << 64) { + return factorize64(target as u64) + .into_iter() + .map(|(k, v)| (u128::from(k), v)) + .collect(); + } + + let mut result = BTreeMap::new(); + + // quick check on factors of 2 + let f2 = target.trailing_zeros(); + if f2 != 0 { + result.insert(2, f2 as usize); + } + let mut residual = target >> f2; + + // trial division using primes in the table + // note that p^2 is never larger than target (at least 64 bits), so we don't need to shortcut trial division + #[cfg(not(feature = "big-table"))] + for p in SMALL_PRIMES.iter().skip(1).map(|&v| v as u128) { + while residual % p == 0 { + residual /= p; + *result.entry(p).or_insert(0) += 1; + } + if residual == 1 { + return result; + } + } + + #[cfg(feature = "big-table")] + // divisibility check with pre-computed tables, see comments on SMALL_PRIMES_INV for reference + for (p, &pinv) in SMALL_PRIMES + .iter() + .map(|&p| u64::from(p)) + .zip(SMALL_PRIMES_INV.iter()) + .skip(1) + { + let mut exp: usize = 0; + while let Some(q) = DivExact::div_exact(residual, p, &pinv) { + exp += 1; + residual = q; + } + if exp > 0 { + result.insert(u128::from(p), exp); + } + + if residual == 1 { + return result; + } + } + + // then try advanced methods to find a divisor util fully factored + for (p, exp) in factorize128_advanced(&[(residual, 1usize)]) { + *result.entry(p).or_insert(0) += exp; + } + result +} + +pub(crate) fn factorize128_advanced(cofactors: &[(u128, usize)]) -> Vec<(u128, usize)> { + let (mut todo128, mut todo64) = ( + Vec::with_capacity(cofactors.len()), + Vec::with_capacity(cofactors.len()), + ); // cofactors to be processed + let mut factored: Vec<(u128, usize)> = Vec::with_capacity(cofactors.len() * 2); // prime factor, exponent + for &(co, e) in cofactors { + if let Ok(co64) = u64::try_from(co) { + todo64.push((co64, e)); + } else { + todo128.push((co, e)); + }; + } + + while let Some((target, exp)) = todo128.pop() { + if is_prime(&SmallMint::from(target), Some(PrimalityTestConfig::bpsw())).probably() { + factored.push((target, exp)); + continue; + } + + // check perfect powers before other methods + // it suffices to check 2, 3, 5, 7 power if big-table is enabled, since tenth power of + // the smallest prime that haven't been checked is 8167^10 > 2^128 + if let Some(d) = target.sqrt_exact() { + if let Ok(d64) = u64::try_from(d) { + todo64.push((d64, exp * 2)); + } else { + todo128.push((d, exp * 2)); + } + continue; + } + if let Some(d) = target.cbrt_exact() { + if let Ok(d64) = u64::try_from(d) { + todo64.push((d64, exp * 3)); + } else { + todo128.push((d, exp * 3)); + } + continue; + } + if let Some(d) = target.nth_root_exact(5) { + if let Ok(d64) = u64::try_from(d) { + todo64.push((d64, exp * 5)); + } else { + todo128.push((d, exp * 5)); + } + continue; + } + if let Some(d) = target.nth_root_exact(7) { + if let Ok(d64) = u64::try_from(d) { + todo64.push((d64, exp * 7)); + } else { + todo128.push((d, exp * 7)); + } + continue; + } + + // try to find a divisor + let mut i = 0usize; + let mut max_iter_ratio = 1; + let mut rng = SplitMix64::new(target as u64 ^ (target >> 64) as u64); + + // Hart's one-line and SQUFOF both cost O(target^(1/4)) per run, which + // only competes with Pollard's rho while the target is small. Above 64 + // bits a single SQUFOF sweep already runs for billions of iterations, + // so keep doubling the rho budget instead of rotating into them. + let nmethods = if target.bits() <= 64 { 3 } else { 1 }; + let divisor = loop { + // try various factorization method iteratively, sort by time per iteration + match i % nmethods { + 0 => { + // Pollard's rho + let start = MontgomeryInt::new(u128::from(rng.next_u64()), &target); + let offset = start.convert(u128::from(rng.next_u64())); + let max_iter = max_iter_ratio << (target.bits() / 6); // unoptimized heuristic + if let (Some(p), _) = pollard_rho( + &SmallMint::from(target), + start.into(), + offset.into(), + max_iter, + ) { + break p.value(); + } + } + 1 => { + // Hart's one-line + let mul_target = target.checked_mul(480).unwrap_or(target); + let max_iter = max_iter_ratio << (mul_target.bits() / 6); // unoptimized heuristic + if let (Some(p), _) = one_line(&target, mul_target, max_iter) { + break p; + } + } + 2 => { + // Shanks's squfof, try all mutipliers + let mut d = None; + for &k in &SQUFOF_MULTIPLIERS { + if let Some(mul_target) = target.checked_mul(u128::from(k)) { + let max_iter = max_iter_ratio * 2 * mul_target.sqrt().sqrt() as usize; + if let (Some(p), _) = squfof(&target, mul_target, max_iter) { + d = Some(p); + break; + } + } + } + if let Some(p) = d { + break p; + } + } + _ => unreachable!(), + } + i += 1; + + // increase max iterations after trying all methods + if i % nmethods == 0 { + max_iter_ratio *= 2; + } + }; + + if let Ok(d64) = u64::try_from(divisor) { + todo64.push((d64, exp)); + } else { + todo128.push((divisor, exp)); + } + let co = target / divisor; + if let Ok(d64) = u64::try_from(co) { + todo64.push((d64, exp)); + } else { + todo128.push((co, exp)); + } + } + + // forward 64 bit cofactors + factored.extend( + factorize64_advanced(&todo64) + .into_iter() + .map(|(p, exp)| (u128::from(p), exp)), + ); + factored +} + +/// Primality test +/// +/// This function re-exports [`PrimeBufferExt::is_prime()`][crate::buffer::PrimeBufferExt::is_prime()] with a new [`NaiveBuffer`] instance +/// +/// # Examples +/// +/// ``` +/// use num_prime::nt_funcs::is_prime; +/// +/// assert!(is_prime(&2u64, None).probably()); +/// assert!(is_prime(&13u64, None).probably()); +/// assert!(!is_prime(&15u64, None).probably()); +/// ``` +pub fn is_prime(target: &T, config: Option) -> Primality +where + for<'r> &'r T: PrimalityRefBase, +{ + NaiveBuffer::new().is_prime(target, config) +} + +/// Faillible factorization +/// +/// This function re-exports [`PrimeBufferExt::factors()`][crate::buffer::PrimeBufferExt::factors()] with a new [`NaiveBuffer`] instance +/// +/// # Examples +/// +/// ``` +/// use num_prime::nt_funcs::factors; +/// +/// let (fac, unfactored) = factors(60u64, None); +/// assert_eq!(fac[&2], 2); +/// assert_eq!(fac[&3], 1); +/// assert_eq!(fac[&5], 1); +/// assert!(unfactored.is_none()); +/// ``` +pub fn factors( + target: T, + config: Option, +) -> (BTreeMap, Option>) +where + for<'r> &'r T: PrimalityRefBase, +{ + NaiveBuffer::new().factors(target, config) +} + +/// Infaillible factorization +/// +/// This function re-exports [`PrimeBufferExt::factorize()`][crate::buffer::PrimeBufferExt::factorize()] with a new [`NaiveBuffer`] instance +/// +/// # Examples +/// +/// ``` +/// use num_prime::nt_funcs::factorize; +/// +/// let fac = factorize(60u64); +/// assert_eq!(fac[&2], 2); +/// assert_eq!(fac[&3], 1); +/// assert_eq!(fac[&5], 1); +/// ``` +pub fn factorize(target: T) -> BTreeMap +where + for<'r> &'r T: PrimalityRefBase, +{ + NaiveBuffer::new().factorize(target) +} + +/// Get a list of primes under a limit +/// +/// This function re-exports [`NaiveBuffer::primes()`] and collect result as a vector. +/// +/// # Examples +/// +/// ``` +/// use num_prime::nt_funcs::primes; +/// +/// assert_eq!(primes(20), vec![2, 3, 5, 7, 11, 13, 17, 19]); +/// assert_eq!(primes(2), vec![2]); +/// assert!(primes(1).is_empty()); +/// ``` +#[must_use] +pub fn primes(limit: u64) -> Vec { + NaiveBuffer::new().into_primes(limit).collect() +} + +/// Get the first n primes +/// +/// This function re-exports [`NaiveBuffer::nprimes()`] and collect result as a vector. +/// +/// # Examples +/// +/// ``` +/// use num_prime::nt_funcs::nprimes; +/// +/// assert_eq!(nprimes(5), vec![2, 3, 5, 7, 11]); +/// assert!(nprimes(0).is_empty()); +/// ``` +#[must_use] +pub fn nprimes(count: usize) -> Vec { + NaiveBuffer::new().into_nprimes(count).collect() +} + +/// Calculate and return the prime π function +/// +/// This function re-exports [`NaiveBuffer::prime_pi()`] +/// +/// # Examples +/// +/// ``` +/// use num_prime::nt_funcs::prime_pi; +/// +/// assert_eq!(prime_pi(10), 4); // primes: 2, 3, 5, 7 +/// assert_eq!(prime_pi(100), 25); +/// ``` +#[must_use] +pub fn prime_pi(limit: u64) -> u64 { + NaiveBuffer::new().prime_pi(limit) +} + +/// Get the n-th prime (n counts from 1). +/// +/// This function re-exports [`NaiveBuffer::nth_prime()`] +/// +/// # Examples +/// +/// ``` +/// use num_prime::nt_funcs::nth_prime; +/// +/// assert_eq!(nth_prime(1), 2); +/// assert_eq!(nth_prime(5), 11); +/// assert_eq!(nth_prime(25), 97); +/// ``` +#[must_use] +pub fn nth_prime(n: u64) -> u64 { + NaiveBuffer::new().nth_prime(n) +} + +/// Calculate the primorial function +/// +/// Returns the product of the first `n` primes. +/// +/// # Examples +/// +/// ``` +/// use num_prime::nt_funcs::primorial; +/// +/// assert_eq!(primorial::(1), 2); // 2 +/// assert_eq!(primorial::(3), 30); // 2 * 3 * 5 +/// assert_eq!(primorial::(4), 210); // 2 * 3 * 5 * 7 +/// ``` +#[must_use] +pub fn primorial(n: usize) -> T { + NaiveBuffer::new() + .into_nprimes(n) + .map(|p| T::from_u64(p).unwrap()) + .product() +} + +/// This function calculate the Möbius `μ(n)` function of the input integer `n` +/// +/// This function behaves like `moebius_factorized(factorize(target))`. +/// If the input integer is very hard to factorize, it's better to use +/// the [`factors()`] function to control how the factorization is done, and then call +/// [`moebius_factorized()`]. +/// +/// # Examples +/// +/// ``` +/// use num_prime::nt_funcs::moebius; +/// +/// assert_eq!(moebius(&1u64), 1); // μ(1) = 1 +/// assert_eq!(moebius(&2u64), -1); // μ(p) = -1 +/// assert_eq!(moebius(&4u64), 0); // μ(p²) = 0 +/// assert_eq!(moebius(&30u64), -1); // μ(2·3·5) = -1 (odd number of prime factors) +/// assert_eq!(moebius(&6u64), 1); // μ(2·3) = 1 (even number of prime factors) +/// ``` +/// +/// # Panics +/// if the factorization failed on target. +pub fn moebius(target: &T) -> i8 +where + for<'r> &'r T: PrimalityRefBase, +{ + // remove factor 2 + if target.is_even() { + let two = T::one() + T::one(); + let four = &two + &two; + if (target % four).is_zero() { + return 0; + } else { + return -moebius(&(target / &two)); + } + } + + // look up tables when input is smaller than 256 + if let Some(v) = (target - T::one()).to_u8() { + let m = MOEBIUS_ODD[(v >> 6) as usize]; + let m = m & (3 << (v & 63)); + let m = m >> (v & 63); + return m as i8 - 1; + } + + // short cut for common primes + let three_sq = T::from_u8(9).unwrap(); + let five_sq = T::from_u8(25).unwrap(); + let seven_sq = T::from_u8(49).unwrap(); + if (target % three_sq).is_zero() + || (target % five_sq).is_zero() + || (target % seven_sq).is_zero() + { + return 0; + } + + // then try complete factorization + moebius_factorized(&factorize(target.clone())) +} + +/// This function calculate the Möbius `μ(n)` function given the factorization +/// result of `n` +/// +/// # Examples +/// +/// ``` +/// use num_prime::nt_funcs::{moebius_factorized, factorize}; +/// +/// assert_eq!(moebius_factorized(&factorize(30u64)), -1); // 30 = 2·3·5 +/// assert_eq!(moebius_factorized(&factorize(12u64)), 0); // 12 = 2²·3 +/// assert_eq!(moebius_factorized(&factorize(6u64)), 1); // 6 = 2·3 +/// ``` +#[must_use] +pub fn moebius_factorized(factors: &BTreeMap) -> i8 { + if factors.values().any(|exp| exp > &1) { + 0 + } else if factors.len() % 2 == 0 { + 1 + } else { + -1 + } +} + +/// Tests if the integer doesn't have any square number factor. +/// +/// # Examples +/// +/// ``` +/// use num_prime::nt_funcs::is_square_free; +/// +/// assert!(is_square_free(&30u64)); // 30 = 2·3·5 +/// assert!(!is_square_free(&12u64)); // 12 = 2²·3 +/// assert!(is_square_free(&1u64)); +/// ``` +/// +/// # Panics +/// if the factorization failed on target. +pub fn is_square_free(target: &T) -> bool +where + for<'r> &'r T: PrimalityRefBase, +{ + moebius(target) != 0 +} + +/// Returns the estimated bounds (low, high) of prime π function, such that +/// low <= π(target) <= high +/// +/// # Examples +/// +/// ``` +/// use num_prime::nt_funcs::prime_pi_bounds; +/// +/// let (lo, hi) = prime_pi_bounds(&1_000_000u64); +/// // π(1_000_000) = 78498 +/// assert!(lo <= 78498 && 78498 <= hi); +/// ``` +/// +/// # Reference: +/// - \[1] Dusart, Pierre. "Estimates of Some Functions Over Primes without R.H." +/// [arxiv:1002.0442](http://arxiv.org/abs/1002.0442). 2010. +/// - \[2] Dusart, Pierre. "Explicit estimates of some functions over primes." +/// The Ramanujan Journal 45.1 (2018): 227-251. +pub fn prime_pi_bounds(target: &T) -> (T, T) { + if let Some(x) = target.to_u64() { + // use existing primes and return exact value + if x <= u64::from(*SMALL_PRIMES.last().unwrap()) { + #[cfg(not(feature = "big-table"))] + let pos = SMALL_PRIMES.binary_search(&(x as u8)); + #[cfg(feature = "big-table")] + let pos = SMALL_PRIMES.binary_search(&(x as u16)); + + let n = match pos { + Ok(p) => p + 1, + Err(p) => p, + }; + return (T::from_usize(n).unwrap(), T::from_usize(n).unwrap()); + } + + // use function approximation + let n = x as f64; + let ln = n.ln(); + let invln = ln.recip(); + + let lo = match () { + // [2] Collary 5.3 + () if x >= 468_049 => n / (ln - 1. - invln), + // [2] Collary 5.2 + () if x >= 88789 => n * invln * (1. + invln * (1. + 2. * invln)), + // [2] Collary 5.3 + () if x >= 5393 => n / (ln - 1.), + // [2] Collary 5.2 + () if x >= 599 => n * invln * (1. + invln), + // [2] Collary 5.2 + () => n * invln, + }; + let hi = match () { + // [2] Theorem 5.1, valid for x > 4e9, intersects at 7.3986e9 + () if x >= 7_398_600_000 => { + n * invln * (1. + invln * (1. + invln * (2. + invln * 7.59))) + } + // [1] Theorem 6.9 + () if x >= 2_953_652_287 => n * invln * (1. + invln * (1. + invln * 2.334)), + // [2] Collary 5.3, valid for x > 5.6, intersects at 5668 + () if x >= 467_345 => n / (ln - 1. - 1.2311 * invln), + // [2] Collary 5.2, valid for x > 1, intersects at 29927 + () if x >= 29927 => n * invln * (1. + invln * (1. + invln * 2.53816)), + // [2] Collary 5.3, valid for x > exp(1.112), intersects at 5668 + () if x >= 5668 => n / (ln - 1.112), + // [2] Collary 5.2, valid for x > 1, intersects at 148 + () if x >= 148 => n * invln * (1. + invln * 1.2762), + // [2] Collary 5.2, valid for x > 1 + () => 1.25506 * n * invln, + }; + (T::from_f64(lo).unwrap(), T::from_f64(hi).unwrap()) + } else { + let n = target.to_f64().unwrap(); + let ln = n.ln(); + let invln = ln.recip(); + + // best bounds so far + let lo = n / (ln - 1. - invln); + let hi = n * invln * (1. + invln * (1. + invln * (2. + invln * 7.59))); + (T::from_f64(lo).unwrap(), T::from_f64(hi).unwrap()) + } +} + +/// Returns the estimated inclusive bounds (low, high) of the n-th prime. If the result +/// is larger than maximum of `T`, [None] will be returned. +/// +/// # Examples +/// +/// ``` +/// use num_prime::nt_funcs::nth_prime_bounds; +/// +/// let (lo, hi) = nth_prime_bounds(&10_000u64).unwrap(); +/// // The 10000th prime is 104729 +/// assert!(lo <= 104729 && 104729 <= hi); +/// ``` +/// +/// # Reference: +/// - \[1] Dusart, Pierre. "Estimates of Some Functions Over Primes without R.H." +/// arXiv preprint [arXiv:1002.0442](https://arxiv.org/abs/1002.0442) (2010). +/// - \[2] Rosser, J. Barkley, and Lowell Schoenfeld. "Approximate formulas for some +/// functions of prime numbers." Illinois Journal of Mathematics 6.1 (1962): 64-94. +/// - \[3] Dusart, Pierre. "The k th prime is greater than k (ln k+ ln ln k-1) for k≥ 2." +/// Mathematics of computation (1999): 411-415. +/// - \[4] Axler, Christian. ["New Estimates for the nth Prime Number."](https://www.emis.de/journals/JIS/VOL22/Axler/axler17.pdf) +/// Journal of Integer Sequences 22.2 (2019): 3. +/// - \[5] Axler, Christian. [Uber die Primzahl-Zählfunktion, die n-te Primzahl und verallgemeinerte Ramanujan-Primzahlen. Diss.](http://docserv.uniduesseldorf.de/servlets/DerivateServlet/Derivate-28284/pdfa-1b.pdf) +/// `PhD` thesis, Düsseldorf, 2013. +/// +/// Note that some of the results might depend on the Riemann Hypothesis. If you find +/// any prime that doesn't fall in the bound, then it might be a big discovery! +pub fn nth_prime_bounds(target: &T) -> Option<(T, T)> { + if let Some(x) = target.to_usize() { + if x == 0 { + return Some((T::from_u8(0).unwrap(), T::from_u8(0).unwrap())); + } + + // use existing primes and return exact value + if x <= SMALL_PRIMES.len() { + let p = SMALL_PRIMES[x - 1]; + + #[cfg(not(feature = "big-table"))] + return Some((T::from_u8(p).unwrap(), T::from_u8(p).unwrap())); + + #[cfg(feature = "big-table")] + return Some((T::from_u16(p).unwrap(), T::from_u16(p).unwrap())); + } + + // use function approximation + let n = x as f64; + let ln = n.ln(); + let lnln = ln.ln(); + + let lo = match () { + // [4] Theroem 4, valid for x >= 2, intersects as 3.172e5 + () if x >= 317_200 => { + n * (ln + lnln - 1. + (lnln - 2.) / ln + - (lnln * lnln - 6. * lnln + 11.321) / (2. * ln * ln)) + } + // [1] Proposition 6.7, valid for x >= 3, intersects at 3520 + () if x >= 3520 => n * (ln + lnln - 1. + (lnln - 2.1) / ln), + // [3] title + () => n * (ln + lnln - 1.), + }; + let hi = match () { + // [4] Theroem 1, valid for x >= 46254381 + () if x >= 46_254_381 => { + n * (ln + lnln - 1. + (lnln - 2.) / ln + - (lnln * lnln - 6. * lnln + 10.667) / (2. * ln * ln)) + } + // [5] Korollar 2.11, valid for x >= 8009824 + () if x >= 8_009_824 => { + n * (ln + lnln - 1. + (lnln - 2.) / ln + - (lnln * lnln - 6. * lnln + 10.273) / (2. * ln * ln)) + } + // [1] Proposition 6.6 + () if x >= 688_383 => n * (ln + lnln - 1. + (lnln - 2.) / ln), + // [1] Lemma 6.5 + () if x >= 178_974 => n * (ln + lnln - 1. + (lnln - 1.95) / ln), + // [3] in "Further Results" + () if x >= 39017 => n * (ln + lnln - 0.9484), + // [3] in "Further Results" + () if x >= 27076 => n * (ln + lnln - 1. + (lnln - 1.8) / ln), + // [2] Theorem 3, valid for x >= 20 + () => n * (ln + lnln - 0.5), + }; + Some((T::from_f64(lo)?, T::from_f64(hi)?)) + } else { + let n = target.to_f64().unwrap(); + let ln = n.ln(); + let lnln = ln.ln(); + + // best bounds so far + let lo = n + * (ln + lnln - 1. + (lnln - 2.) / ln + - (lnln * lnln - 6. * lnln + 11.321) / (2. * ln * ln)); + let hi = n + * (ln + lnln - 1. + (lnln - 2.) / ln + - (lnln * lnln - 6. * lnln + 10.667) / (2. * ln * ln)); + Some((T::from_f64(lo)?, T::from_f64(hi)?)) + } +} + +/// Test if the target is a safe prime under [Sophie German's definition](https://en.wikipedia.org/wiki/Safe_and_Sophie_Germain_primes). It will use the +/// [strict primality test configuration][FactorizationConfig::strict()]. +/// +/// # Examples +/// +/// ``` +/// use num_prime::nt_funcs::is_safe_prime; +/// +/// assert!(is_safe_prime(&5u64).probably()); // (5-1)/2 = 2, prime +/// assert!(is_safe_prime(&7u64).probably()); // (7-1)/2 = 3, prime +/// assert!(is_safe_prime(&23u64).probably()); // (23-1)/2 = 11, prime +/// assert!(!is_safe_prime(&13u64).probably()); // (13-1)/2 = 6, not prime +/// ``` +pub fn is_safe_prime(target: &T) -> Primality +where + for<'r> &'r T: PrimalityRefBase, +{ + let buf = NaiveBuffer::new(); + let config = Some(PrimalityTestConfig::strict()); + + // test (n-1)/2 first since its smaller + let sophie_p = buf.is_prime(&(target >> 1), config); + if matches!(sophie_p, Primality::No) { + return sophie_p; + } + + // and then test target itself + let target_p = buf.is_prime(target, config); + target_p & sophie_p +} + +/// Find the first prime number larger than `target`. If the result causes an overflow, +/// then [None] will be returned +/// +/// # Examples +/// +/// ``` +/// use num_prime::nt_funcs::next_prime; +/// +/// assert_eq!(next_prime(&13u32, None), Some(17)); +/// assert_eq!(next_prime(&1000u32, None), Some(1009)); +/// ``` +#[cfg(not(feature = "big-table"))] +pub fn next_prime( + target: &T, + config: Option, +) -> Option +where + for<'r> &'r T: PrimalityRefBase, +{ + // first search in small primes + if let Some(x) = target.to_u8() { + return match SMALL_PRIMES.binary_search(&x) { + Ok(pos) => { + if pos + 1 == SMALL_PRIMES.len() { + T::from_u64(SMALL_PRIMES_NEXT) + } else { + T::from_u8(SMALL_PRIMES[pos + 1]) + } + } + Err(pos) if pos < SMALL_PRIMES.len() => T::from_u8(SMALL_PRIMES[pos]), + Err(_) => T::from_u64(SMALL_PRIMES_NEXT), + }; + } + + // then moving along the wheel + let mut i = (target % T::from_u8(WHEEL_SIZE).unwrap()).to_u8().unwrap(); + let mut t = target.clone(); + loop { + let offset = WHEEL_NEXT[i as usize]; + t = t.checked_add(&T::from_u8(offset).unwrap())?; + i = i.addm(offset, &WHEEL_SIZE); + if is_prime(&t, config).probably() { + break Some(t); + } + } +} + +/// Find the first prime number larger than `target`. If the result causes an overflow, +/// then [None] will be returned +/// +/// # Examples +/// +/// ``` +/// use num_prime::nt_funcs::next_prime; +/// +/// assert_eq!(next_prime(&13u32, None), Some(17)); +/// assert_eq!(next_prime(&1000u32, None), Some(1009)); +/// ``` +#[cfg(feature = "big-table")] +pub fn next_prime( + target: &T, + config: Option, +) -> Option +where + for<'r> &'r T: PrimalityRefBase, +{ + // first search in small primes + if target <= &T::from_u8(255).unwrap() // shortcut for T=u8 + || target < &T::from_u16(*SMALL_PRIMES.last().unwrap()).unwrap() + { + let next = match SMALL_PRIMES.binary_search(&target.to_u16().unwrap()) { + Ok(pos) => SMALL_PRIMES[pos + 1], + Err(pos) => SMALL_PRIMES[pos], + }; + return T::from_u16(next); + } + + // then moving along the wheel + let mut i = (target % T::from_u16(WHEEL_SIZE).unwrap()) + .to_u16() + .unwrap(); + let mut t = target.clone(); + loop { + let offset = WHEEL_NEXT[i as usize]; + t = t.checked_add(&T::from_u8(offset).unwrap())?; + i = i.addm(u16::from(offset), &WHEEL_SIZE); + if is_prime(&t, config).probably() { + break Some(t); + } + } +} + +/// Find the first prime number smaller than `target`. If target is less than 3, then [None] +/// will be returned. +/// +/// # Examples +/// +/// ``` +/// use num_prime::nt_funcs::prev_prime; +/// +/// assert_eq!(prev_prime(&13u32, None), Some(11)); +/// assert_eq!(prev_prime(&1000u32, None), Some(997)); +/// assert_eq!(prev_prime(&2u32, None), None); +/// ``` +#[cfg(not(feature = "big-table"))] +pub fn prev_prime(target: &T, config: Option) -> Option +where + for<'r> &'r T: PrimalityRefBase, +{ + if target <= &(T::one() + T::one()) { + return None; + } + + // first search in small primes + if let Some(x) = target.to_u8() { + let next = match SMALL_PRIMES.binary_search(&x) { + Ok(pos) => SMALL_PRIMES[pos - 1], + Err(pos) => SMALL_PRIMES[pos - 1], + }; + return Some(T::from_u8(next).unwrap()); + } + + // then moving along the wheel + let mut i = (target % T::from_u8(WHEEL_SIZE).unwrap()).to_u8().unwrap(); + let mut t = target.clone(); + loop { + let offset = WHEEL_PREV[i as usize]; + t = t - T::from_u8(offset).unwrap(); + i = i.subm(offset, &WHEEL_SIZE); + if is_prime(&t, config).probably() { + break Some(t); + } + } +} + +/// Find the first prime number smaller than `target`. If target is less than 3, then [None] +/// will be returned. +/// +/// # Examples +/// +/// ``` +/// use num_prime::nt_funcs::prev_prime; +/// +/// assert_eq!(prev_prime(&13u32, None), Some(11)); +/// assert_eq!(prev_prime(&1000u32, None), Some(997)); +/// assert_eq!(prev_prime(&2u32, None), None); +/// ``` +#[cfg(feature = "big-table")] +pub fn prev_prime(target: &T, config: Option) -> Option +where + for<'r> &'r T: PrimalityRefBase, +{ + if target <= &(T::one() + T::one()) { + return None; + } + + // first search in small primes + if target <= &T::from_u8(255).unwrap() // shortcut for u8 + || target < &T::from_u16(*SMALL_PRIMES.last().unwrap()).unwrap() + { + let next = match SMALL_PRIMES.binary_search(&target.to_u16().unwrap()) { + Ok(pos) => SMALL_PRIMES[pos - 1], + Err(pos) => SMALL_PRIMES[pos - 1], + }; + return Some(T::from_u16(next).unwrap()); + } + + // then moving along the wheel + let mut i = (target % T::from_u16(WHEEL_SIZE).unwrap()) + .to_u16() + .unwrap(); + let mut t = target.clone(); + loop { + let offset = WHEEL_PREV[i as usize]; + t = t - T::from_u8(offset).unwrap(); + i = i.subm(u16::from(offset), &WHEEL_SIZE); + if is_prime(&t, config).probably() { + break Some(t); + } + } +} + +/// Estimate the value of prime π() function by averaging the estimated bounds. +/// +/// # Examples +/// +/// ``` +/// use num_prime::nt_funcs::{prime_pi_est, prime_pi_bounds}; +/// +/// let est = prime_pi_est(&1_000_000u64); +/// let (lo, hi) = prime_pi_bounds(&1_000_000u64); +/// assert!(lo <= est && est <= hi); +/// ``` +#[cfg(not(feature = "big-table"))] +pub fn prime_pi_est(target: &T) -> T { + let (lo, hi) = prime_pi_bounds(target); + (lo + hi) / T::from_u8(2).unwrap() +} + +/// Estimate the value of prime `π()` function by Riemann's R function. The estimation +/// error is roughly of scale O(sqrt(x)log(x)). +/// +/// Reference: +/// +/// # Examples +/// +/// ``` +/// use num_prime::nt_funcs::{prime_pi_est, prime_pi_bounds}; +/// +/// let est = prime_pi_est(&1_000_000u64); +/// let (lo, hi) = prime_pi_bounds(&1_000_000u64); +/// assert!(lo <= est && est <= hi); +/// ``` +#[cfg(feature = "big-table")] +pub fn prime_pi_est(target: &T) -> T { + // shortcut + if let Some(x) = target.to_u16() { + if x <= { *SMALL_PRIMES.last().unwrap() } { + let (lo, hi) = prime_pi_bounds(&x); + debug_assert_eq!(lo, hi); + return T::from_u16(lo).unwrap(); + } + } + + // Gram expansion with logarithm arithmetics + let lnln = target.to_f64().unwrap().ln().ln(); + let mut total = 0f64; + let mut lnp = 0f64; // k*ln(ln(x)) + let mut lnfac = 0f64; // ln(k!) + + for k in 1usize..100 { + lnp += lnln; + let lnk = (k as f64).ln(); + lnfac += lnk; + let lnzeta = if k > 64 { 0f64 } else { ZETA_LOG_TABLE[k - 1] }; + let t = lnp - lnk - lnfac - lnzeta; + if t < -4. { + // stop if the increment is too small + break; + } + total += t.exp(); + } + T::from_f64(total + 1f64).unwrap() +} + +/// Estimate the value of nth prime by bisecting on [`prime_pi_est`]. +/// If the result is larger than maximum of `T`, [None] will be returned. +/// +/// # Examples +/// +/// ``` +/// use num_prime::nt_funcs::{nth_prime_est, nth_prime_bounds}; +/// +/// let est = nth_prime_est(&10_000u64).unwrap(); +/// let (lo, hi) = nth_prime_bounds(&10_000u64).unwrap(); +/// assert!(lo <= est && est <= hi); +/// ``` +pub fn nth_prime_est(target: &T) -> Option +where + for<'r> &'r T: RefNum, +{ + let (mut lo, mut hi) = nth_prime_bounds(target)?; + if lo == hi { + return Some(lo); + } + + while lo != &hi - T::from_u8(1).unwrap() { + let x = (&lo + &hi) / T::from_u8(2).unwrap(); + let mid = prime_pi_est(&x); + if &mid < target { + lo = x; + } else if &mid > target { + hi = x; + } else { + return Some(x); + } + } + Some(lo) +} + +// TODO: More functions +// REF: http://www.numbertheory.org/gnubc/bc_programs.html +// REF: https://github.com/TilmanNeumann/java-math-library +// - is_smooth: checks if the smoothness bound is at least b +// - euler_phi: Euler's totient function +// - jordan_tot: Jordan's totient function +// Others include Louiville function, Mangoldt function, Dedekind psi function, Dickman rho function, etc.. + +#[cfg(test)] +mod tests { + use super::*; + use rand::{prelude::SliceRandom, random}; + use std::iter::FromIterator; + + /// 529341446939 * 529341447079 * 529341447139. SQUFOF and Hart's one-line + /// both cost O(n^(1/4)), so rotating into them on a 117-bit target used to + /// burn tens of seconds before Pollard's rho got another chance. + #[test] + fn factorize128_three_large_primes() { + let factors = factorize128(148_322_726_715_648_124_896_087_586_879_631_159); + assert_eq!( + factors, + BTreeMap::from_iter([ + (529_341_446_939, 1), + (529_341_447_079, 1), + (529_341_447_139, 1) + ]) + ); + } + + #[test] + fn is_prime64_test() { + // test small primes + for x in 2..100 { + assert_eq!(SMALL_PRIMES.contains(&x), is_prime64(u64::from(x))); + } + assert!(is_prime64(677)); + + // from PR #7 + assert!(!is_prime64(9773)); + assert!(!is_prime64(13357)); + assert!(!is_prime64(18769)); + + // some large primes + assert!(is_prime64(6_469_693_333)); + assert!(is_prime64(13_756_265_695_458_089_029)); + assert!(is_prime64(13_496_181_268_022_124_907)); + assert!(is_prime64(10_953_742_525_620_032_441)); + assert!(is_prime64(17_908_251_027_575_790_097)); + + // primes from examples in Bradley Berg's hash method + assert!(is_prime64(480_194_653)); + assert!(!is_prime64(20_074_069)); + assert!(is_prime64(8_718_775_377_449)); + assert!(is_prime64(3_315_293_452_192_821_991)); + assert!(!is_prime64(8_651_776_913_431)); + assert!(!is_prime64(1_152_965_996_591_997_761)); + + // false positives reported by JASory (#4) + assert!(!is_prime64(600_437_059_821_397)); + assert!(!is_prime64(3_866_032_210_719_337)); + assert!(!is_prime64(4_100_599_722_623_587)); + + // ensure no factor for 100 random primes + let mut rng = rand::thread_rng(); + for _ in 0..100 { + let x = random(); + if !is_prime64(x) { + continue; + } + assert_ne!(x % u64::from(*SMALL_PRIMES.choose(&mut rng).unwrap()), 0); + } + + // create random composites + for _ in 0..100 { + let x = u64::from(random::()); + let y = u64::from(random::()); + assert!(!is_prime64(x * y)); + } + } + + #[test] + fn factorize64_test() { + // some simple cases + let fac4095 = BTreeMap::from_iter([(3, 2), (5, 1), (7, 1), (13, 1)]); + let fac = factorize64(4095); + assert_eq!(fac, fac4095); + + let fac123456789 = BTreeMap::from_iter([(3, 2), (3803, 1), (3607, 1)]); + let fac = factorize64(123_456_789); + assert_eq!(fac, fac123456789); + + let fac1_17 = BTreeMap::from_iter([(2_071_723, 1), (5_363_222_357, 1)]); + let fac = factorize64(11_111_111_111_111_111); + assert_eq!(fac, fac1_17); + + // perfect powers + for exp in 2u32..5 { + assert_eq!( + factorize128(8167u128.pow(exp)), + BTreeMap::from_iter([(8167, exp as usize)]) + ); + } + + // 100 random factorization tests + for _ in 0..100 { + let x = random(); + let fac = factorize64(x); + let mut prod = 1; + for (p, exp) in fac { + assert!( + is_prime64(p), + "factorization result should have prime factors! (get {})", + p + ); + prod *= p.pow(exp as u32); + } + assert_eq!(x, prod, "factorization check failed! ({x} != {prod})"); + } + } + + #[test] + fn factorize128_test() { + // some simple cases + let fac_primorial19 = + BTreeMap::from_iter(SMALL_PRIMES.iter().take(19).map(|&p| (u128::from(p), 1))); + let fac = factorize128(7_858_321_551_080_267_055_879_090); + assert_eq!(fac, fac_primorial19); + + let fac_smallbig = BTreeMap::from_iter([(167, 1), (2_417_851_639_229_258_349_412_369, 1)]); + let fac = factorize128(403_781_223_751_286_144_351_865_623); + assert_eq!(fac, fac_smallbig); + + // perfect powers + for exp in 5u32..10 { + // 2^64 < 8167^5 < 8167^9 < 2^128 + assert_eq!( + factorize128(8167u128.pow(exp)), + BTreeMap::from_iter([(8167, exp as usize)]) + ); + } + + // random factorization tests + for _ in 0..4 { + let x = random::() >> 28; // test 100 bit numbers + let fac = factorize128(x); + let mut prod = 1; + for (p, exp) in fac { + assert!( + is_prime(&p, None).probably(), + "factorization result should have prime factors! (get {})", + p + ); + prod *= p.pow(exp as u32); + } + assert_eq!(x, prod, "factorization check failed! ({x} != {prod})"); + } + } + + #[test] + fn is_safe_prime_test() { + // OEIS:A005385 + let safe_primes = [ + 5u16, 7, 11, 23, 47, 59, 83, 107, 167, 179, 227, 263, 347, 359, 383, 467, 479, 503, + 563, 587, 719, 839, 863, 887, 983, 1019, 1187, 1283, 1307, 1319, 1367, 1439, 1487, + 1523, 1619, 1823, 1907, + ]; + for p in SMALL_PRIMES { + #[allow(clippy::unnecessary_cast)] + let p = p as u16; + if p > 1500 { + break; + } + assert_eq!( + is_safe_prime(&p).probably(), + safe_primes.iter().any(|v| &p == v) + ); + } + } + + #[test] + fn moebius_test() { + // test small examples + let mu20: [i8; 20] = [ + 1, -1, -1, 0, -1, 1, -1, 0, 0, 1, -1, 0, -1, 1, 1, 0, -1, 0, -1, 0, + ]; + for (i, &expected) in mu20.iter().enumerate() { + assert_eq!(moebius(&(i + 1)), expected, "moebius on {i}"); + } + + // some square numbers + assert_eq!(moebius(&1024u32), 0); + assert_eq!(moebius(&(8081u32 * 8081)), 0); + + // sphenic numbers + let sphenic3: [u8; 20] = [ + 30, 42, 66, 70, 78, 102, 105, 110, 114, 130, 138, 154, 165, 170, 174, 182, 186, 190, + 195, 222, + ]; // OEIS:A007304 + for &val in &sphenic3 { + assert_eq!(moebius(&val), -1i8, "moebius on {val}"); + } + let sphenic5: [u16; 23] = [ + 2310, 2730, 3570, 3990, 4290, 4830, 5610, 6006, 6090, 6270, 6510, 6630, 7410, 7590, + 7770, 7854, 8610, 8778, 8970, 9030, 9282, 9570, 9690, + ]; // OEIS:A046387 + for &val in sphenic5.iter().take(20) { + assert_eq!(moebius(&val), -1i8, "moebius on {val}"); + } + } + + #[test] + fn prime_pi_bounds_test() { + fn check(n: u64, pi: u64) { + let (lo, hi) = prime_pi_bounds(&n); + let est = prime_pi_est(&n); + assert!( + lo <= pi && pi <= hi, + "fail to satisfy {} <= pi({}) = {} <= {}", + lo, + n, + pi, + hi + ); + assert!(lo <= est && est <= hi); + } + + // test with sieved primes + let mut pb = NaiveBuffer::new(); + let mut last = 0; + for (i, p) in pb.primes(100_000).copied().enumerate() { + for j in last..p { + check(j, i as u64); + } + last = p; + } + + // test with some known cases with input as 10^n, OEIS:A006880 + let pow10_values = [ + 0, + 4, + 25, + 168, + 1229, + 9592, + 78498, + 664_579, + 5_761_455, + 50_847_534, + 455_052_511, + 4_118_054_813, + 37_607_912_018, + 346_065_536_839, + 3_204_941_750_802, + 29_844_570_422_669, + 279_238_341_033_925, + 2_623_557_157_654_233, + ]; + for (exponent, gt) in pow10_values.iter().enumerate() { + let n = 10u64.pow(exponent as u32); + check(n, *gt); + } + } + + #[test] + fn nth_prime_bounds_test() { + fn check(n: u64, p: u64) { + let (lo, hi) = super::nth_prime_bounds(&n).unwrap(); + assert!( + lo <= p && p <= hi, + "fail to satisfy: {} <= {}-th prime = {} <= {}", + lo, + n, + p, + hi + ); + let est = super::nth_prime_est(&n).unwrap(); + assert!(lo <= est && est <= hi); + } + + // test with sieved primes + let mut pb = NaiveBuffer::new(); + for (i, p) in pb.primes(100_000).copied().enumerate() { + check(i as u64 + 1, p); + } + + // test with some known cases with input as 10^n, OEIS:A006988 + let pow10_values = [ + 2, + 29, + 541, + 7919, + 104_729, + 1_299_709, + 15_485_863, + 179_424_673, + 2_038_074_743, + 22_801_763_489, + 252_097_800_623, + 2_760_727_302_517, + 29_996_224_275_833, + 323_780_508_946_331, + 3_475_385_758_524_527, + 37_124_508_045_065_437, + ]; + for (exponent, nth_prime) in pow10_values.iter().enumerate() { + let n = 10u64.pow(exponent as u32); + check(n, *nth_prime); + } + } + + #[test] + fn prev_next_test() { + assert_eq!(prev_prime(&2u32, None), None); + + // prime table boundary test + assert_eq!(prev_prime(&257u16, None), Some(251)); + assert_eq!(next_prime(&251u16, None), Some(257)); + assert_eq!(next_prime(&251u8, None), None); + assert_eq!(prev_prime(&8167u16, None), Some(8161)); + assert_eq!(next_prime(&8161u16, None), Some(8167)); + + // OEIS:A077800 + let twine_primes: [(u32, u32); 8] = [ + (2, 3), // not exactly twine + (3, 5), + (5, 7), + (11, 13), + (17, 19), + (29, 31), + (41, 43), + (617, 619), + ]; + for (p1, p2) in twine_primes { + assert_eq!(prev_prime(&p2, None).unwrap(), p1); + assert_eq!(next_prime(&p1, None).unwrap(), p2); + } + + let adj10_primes: [(u32, u32); 7] = [ + (7, 11), + (97, 101), + (997, 1009), + (9973, 10007), + (99991, 100_003), + (999_983, 1_000_003), + (9_999_991, 10_000_019), + ]; + for (i, (p1, p2)) in adj10_primes.iter().enumerate() { + assert_eq!(prev_prime(p2, None).unwrap(), *p1); + assert_eq!(next_prime(p1, None).unwrap(), *p2); + + let pow = 10u32.pow((i + 1) as u32); + assert_eq!(prev_prime(&pow, None).unwrap(), *p1); + assert_eq!(next_prime(&pow, None).unwrap(), *p2); + } + } + + #[test] + fn factors_overflow_test() { + // Test for issue #23: multiplication overflow in one_line factorization + // This should not panic in debug builds + let problematic_number = 0x3ffffffffffffff8u64; + let (factors_map, cofactors) = factors(problematic_number, None); + + // Verify that we get the correct factorization: 2^3 × 179951 × 3203431780337 + // The function should not panic due to overflow + assert!(!factors_map.is_empty(), "Should find at least some factors"); + + // Verify the product of all factors equals the original number + let mut product = 1u64; + for (factor, count) in &factors_map { + product = product + .checked_mul(factor.pow(*count as u32)) + .expect("Product computation should not overflow"); + } + if let Some(ref remaining) = cofactors { + for cofactor in remaining { + product = product + .checked_mul(*cofactor) + .expect("Product computation should not overflow"); + } + } + assert_eq!( + product, problematic_number, + "Product of factors should equal original number" + ); + } +} diff --git a/vendor/num-prime/src/primality.rs b/vendor/num-prime/src/primality.rs new file mode 100644 index 0000000..7d2ad3d --- /dev/null +++ b/vendor/num-prime/src/primality.rs @@ -0,0 +1,643 @@ +use crate::traits::{BitTest, ExactRoots, PrimalityUtils}; +use either::Either; +use num_integer::{Integer, Roots}; +use num_modular::{ModularCoreOps, ModularRefOps, ModularUnaryOps}; +use num_traits::{FromPrimitive, NumRef, RefNum, ToPrimitive}; + +/// Utilities for the Lucas pseudoprime test +pub trait LucasUtils { + /// Find Lucas sequence to n with modulo m, i.e. $U_{n+1}(P,Q)$ mod m and $V_{n+1}(P,Q)$ + fn lucasm(p: usize, q: isize, m: Self, n: Self) -> (Self, Self) + where + Self: Sized; + + /// Find proper parameters P and Q of Lucas pseudoprime test for n, such that Jacobi(D|n) is -1, + /// using Selfridge's method (referred as method A by Baillie). + fn pq_selfridge(n: &Self) -> (usize, isize); + + /// Find proper parameters P of extra strong Lucas pseudoprime test for n, such that Jacobi(D|n) is -1, + /// using brute-force searching (referred as method C by Baillie) + fn p_bruteforce(n: &Self) -> usize; +} + +impl LucasUtils for T +where + T: Integer + + FromPrimitive + + ToPrimitive + + NumRef + + BitTest + + ExactRoots + + Clone + + ModularRefOps, + for<'r> &'r T: + RefNum + ModularUnaryOps<&'r T, Output = T> + ModularCoreOps<&'r T, &'r T, Output = T>, +{ + fn lucasm(p: usize, q: isize, m: Self, n: Self) -> (Self, Self) { + // Reference: + // and Peter Hackman, "Elementary Number Theory", section "L.XVII Scalar" + + let p = T::from_usize(p).unwrap() % &m; + let q = if q >= 0 { + T::from_isize(q).unwrap() % &m + } else { + T::from_isize(-q).unwrap().negm(&m) + }; + + let mut uk = T::zero() % &m; // U(k), mod m for montgomery form + let mut uk1 = T::one() % &m; // U(k+1) + + for i in (0..n.bits()).rev() { + if n.bit(i) { + // k' = 2k+1 + // U(k'+1) = U(2k+2) = PU(k+1)² - 2*QU(k+1)U(k) + let uk1sq = (&uk1).sqm(&m); + let t1 = (&p).mulm(&uk1sq, &m); + let t2 = (&q).mulm(&uk1, &m).mulm(&uk, &m).dblm(&m); + let new_uk1 = t1.subm(&t2, &m); + // U(k') = U(2k+1) = U(k+1)² - QU(k)² + let t1 = uk1sq; + let t2 = (&q).mulm(&uk.sqm(&m), &m); + let new_uk = t1.subm(&t2, &m); + uk1 = new_uk1; + uk = new_uk; + } else { + // k' = 2k + // U(k'+1) = U(2k+1) = U(k+1)² - QU(k)² + let uksq = (&uk).sqm(&m); + let t1 = (&uk1).sqm(&m); + let t2 = (&uksq).mulm(&q, &m); + let new_uk1 = t1.subm(&t2, &m); + // U(k') = U(2k) = 2U(k+1)U(k) - PU(k)² + let t1 = uk1.mulm(&uk, &m).dblm(&m); + let t2 = uksq.mulm(&p, &m); + let new_uk = t1.subm(&t2, &m); + uk1 = new_uk1; + uk = new_uk; + } + } + + // V(k) = 2U(k+1) - PU(k) + let vk = (&uk1).dblm(&m).subm(&p.mulm(&uk, &m), &m); + (uk, vk) + } + + fn pq_selfridge(n: &Self) -> (usize, isize) { + let mut d = T::from_u8(5).unwrap(); + let mut neg = false; + loop { + // check if n is a square number after several trials + if d == T::from_u8(13).unwrap() && (*n).is_square() { + break (0, 0); + } + + let sd = if neg { (&d).negm(n) } else { d.clone() }; + let j = sd.jacobi(n); + if j == 0 && &d != n { + break (0, 0); + } // modification from Baillie, see https://oeis.org/A217120/a217120_1.txt + if j == -1 { + let d = if neg { + -d.to_isize().unwrap() + } else { + d.to_isize().unwrap() + }; + break (1, (1 - d) / 4); + } + + d = d + T::from_u8(2).unwrap(); + neg = !neg; + } + } + + fn p_bruteforce(n: &Self) -> usize { + let mut p: usize = 3; + loop { + // check if n is a square number after several trials + if p == 10 && (*n).is_square() { + break 0; + } + + let d = T::from_usize(p * p - 4).unwrap(); + let j = d.jacobi(n); + if j == 0 && &d != n { + break 0; + } + if j == -1 { + break p; + } + p += 1; + } + } +} + +impl + PrimalityUtils for T +where + for<'r> &'r T: + RefNum + std::ops::Shr + ModularUnaryOps<&'r T, Output = T>, +{ + #[inline] + fn is_prp(&self, base: Self) -> bool { + if self < &Self::one() { + return false; + } + let tm1 = self - Self::one(); + base.powm(&tm1, self).is_one() + } + + #[inline] + fn is_sprp(&self, base: Self) -> bool { + self.test_sprp(base).either(|v| v, |_| false) + } + + fn test_sprp(&self, base: T) -> Either { + if self <= &Self::one() { + return Either::Left(false); + } + + // find 2^shift*u + 1 = n + let tm1 = self - T::one(); + let shift = tm1.trailing_zeros(); + let u = &tm1 >> shift; + + // prevent reduction if the input is in montgomery form + let m1 = T::one() % self; + let mm1 = (&m1).negm(self); + + let mut x = base.powm(&u, self); + if x == m1 || x == mm1 { + return Either::Left(true); + } + + for _ in 0..shift { + let y = (&x).sqm(self); + if y == m1 { + return Either::Right(self.gcd(&(x - T::one()))); + } + if y == mm1 { + return Either::Left(true); + } + x = y; + } + + Either::Left(x == m1) + } + + fn is_lprp(&self, p: Option, q: Option) -> bool { + if self < &Self::one() { + return false; + } + if self.is_even() { + return false; + } + + let (p, q) = match (p, q) { + (Some(sp), Some(sq)) => (sp, sq), + (_, _) => { + let (sp, sq) = LucasUtils::pq_selfridge(self); + if sp == 0 { + return false; + }; // is a perfect power + (sp, sq) + } + }; + + let d = (p * p) as isize - 4 * q; + let d = if d > 0 { + Self::from_isize(d).unwrap() + } else { + Self::from_isize(-d).unwrap().negm(self) + }; + let delta = match d.jacobi(self) { + 0 => self.clone(), + -1 => self + Self::one(), + 1 => self - Self::one(), + _ => unreachable!(), + }; + let (u, _) = LucasUtils::lucasm(p, q, self.clone(), delta); + u.is_zero() + } + + fn is_slprp(&self, p: Option, q: Option) -> bool { + if self < &Self::one() { + return false; + } + if self.is_even() { + return false; + } + + let (p, q) = match (p, q) { + (Some(sp), Some(sq)) => (sp, sq), + (_, _) => { + let (sp, sq) = LucasUtils::pq_selfridge(self); + if sp == 0 { + return false; + }; // is a perfect power + (sp, sq) + } + }; + + let d = (p * p) as isize - 4 * q; + let d = if d > 0 { + Self::from_isize(d).unwrap() + } else { + Self::from_isize(-d).unwrap().negm(self) + }; + let delta = match d.jacobi(self) { + 0 => self.clone(), + -1 => self + Self::one(), + 1 => self - Self::one(), + _ => unreachable!(), + }; + + let shift = delta.trailing_zeros(); + let base = &delta >> shift; + + let (ud, vd) = LucasUtils::lucasm(p, q, self.clone(), base.clone()); + if ud.is_zero() || vd.is_zero() { + return true; + } + + // do first iteration to remove the sign on Q + if shift == 0 { + return false; + } + let mut qk = Self::from_isize(q.abs()).unwrap().powm(&base, self); + // V(2k) = V(k)² - 2Q^k + let mut vd = if q >= 0 { + vd.sqm(self).subm(&(&qk).dblm(self), self) + } else { + vd.sqm(self).addm(&(&qk).dblm(self), self) + }; + if vd.is_zero() { + return true; + } + + for _ in 1..shift { + // V(2k) = V(k)² - 2Q^k + qk = qk.sqm(self); + vd = vd.sqm(self).subm(&(&qk).dblm(self), self); + if vd.is_zero() { + return true; + } + } + false + } + + fn is_eslprp(&self, p: Option) -> bool { + if self < &Self::one() { + return false; + } + if self.is_even() { + return false; + } + + let p = match p { + Some(sp) => sp, + None => { + let sp = LucasUtils::p_bruteforce(self); + if sp == 0 { + return false; + }; // is a perfect power + sp + } + }; + + let d = (p * p) as isize - 4; + let d = if d > 0 { + Self::from_isize(d).unwrap() + } else { + Self::from_isize(-d).unwrap().negm(self) + }; + let delta = match d.jacobi(self) { + 0 => self.clone(), + -1 => self + Self::one(), + 1 => self - Self::one(), + _ => unreachable!(), + }; + + let shift = delta.trailing_zeros(); + let base = &delta >> shift; + + let (ud, mut vd) = LucasUtils::lucasm(p, 1, self.clone(), base.clone()); + let two = Self::from_u8(2).unwrap(); + // U(d) = 0 or V(d) = ±2 + if ud.is_zero() && (vd == two || vd == self - &two) { + return true; + } + if vd.is_zero() { + return true; + } + + for _ in 1..(shift - 1) { + // V(2k) = V(k)² - 2 + vd = vd.sqm(self).subm(&two, self); + if vd.is_zero() { + return true; + } + } + false + } +} + +/// A dummy trait for integer type. All types that implements this and [`PrimalityRefBase`] +/// will be supported by most functions in `num-primes` +pub trait PrimalityBase: + Integer + + Roots + + NumRef + + Clone + + FromPrimitive + + ToPrimitive + + ExactRoots + + BitTest + + ModularRefOps +{ +} +impl< + T: Integer + + Roots + + NumRef + + Clone + + FromPrimitive + + ToPrimitive + + ExactRoots + + BitTest + + ModularRefOps, + > PrimalityBase for T +{ +} + +/// A dummy trait for integer reference type. All types that implements this and [`PrimalityBase`] +/// will be supported by most functions in `num-primes` +pub trait PrimalityRefBase: + RefNum + + std::ops::Shr + + for<'r> ModularUnaryOps<&'r Base, Output = Base> + + for<'r> ModularCoreOps<&'r Base, &'r Base, Output = Base> +{ +} +impl PrimalityRefBase for T where + T: RefNum + + std::ops::Shr + + for<'r> ModularUnaryOps<&'r Base, Output = Base> + + for<'r> ModularCoreOps<&'r Base, &'r Base, Output = Base> +{ +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::mint::SmallMint; + use num_modular::{ModularAbs, ModularSymbols}; + use rand::random; + + #[cfg(feature = "big-int")] + use num_bigint::BigUint; + + #[test] + fn fermat_prp_test() { + // 341 is the smallest pseudoprime for base 2 + assert!(341u16.is_prp(2)); + assert!(!340u16.is_prp(2)); + assert!(!105u16.is_prp(2)); + + // Carmichael number 561 = 3*11*17 is fermat pseudoprime for any base coprime to 561 + for p in [2, 5, 7, 13, 19] { + assert!(561u32.is_prp(p)); + } + } + + #[test] + fn sprp_test() { + // strong pseudoprimes of base 2 (OEIS:A001262) under 10000 + let spsp: [u16; 5] = [2047, 3277, 4033, 4681, 8321]; + for psp in spsp { + assert!(psp.is_sprp(2)); + assert!(SmallMint::from(psp).is_sprp(2.into())); // test Mint execution + } + + // test cofactor return + assert_eq!(341u16.test_sprp(2), Either::Right(31)); + assert_eq!( + SmallMint::from(341u16).test_sprp(2.into()), + Either::Right(31.into()) + ); + } + + #[test] + fn sprp_rejects_one() { + // One is not prime, and the test used to answer that it is: with + // n - 1 == 0 the shift below runs off the end of the word. + assert_eq!(1u16.test_sprp(2), Either::Left(false)); + assert!(!1u16.is_sprp(2)); + assert!(!SmallMint::from(1u16).is_sprp(2.into())); + #[cfg(feature = "big-int")] + { + assert_eq!( + BigUint::from(1u8).test_sprp(BigUint::from(2u8)), + Either::Left(false) + ); + assert!(!BigUint::from(1u8).is_sprp(BigUint::from(2u8))); + } + } + + #[test] + fn lucas_mod_test() { + // OEIS:A006190 + let p3qm1: [u64; 26] = [ + 0, + 1, + 3, + 10, + 33, + 109, + 360, + 1189, + 3927, + 12970, + 42837, + 141_481, + 467_280, + 1_543_321, + 5_097_243, + 16_835_050, + 55_602_393, + 183_642_229, + 606_529_080, + 2_003_229_469, + 6_616_217_487, + 21_851_881_930, + 72_171_863_277, + 238_367_471_761, + 787_274_278_560, + 2_600_190_307_441, + ]; + let m = random::(); + for (n, &p3qm1_val) in p3qm1.iter().enumerate().skip(2) { + let (uk, _) = LucasUtils::lucasm(3, -1, u64::from(m), n as u64); + assert_eq!(uk, p3qm1_val % u64::from(m)); + + #[cfg(feature = "big-int")] + { + let (uk, _) = LucasUtils::lucasm(3, -1, BigUint::from(m), BigUint::from(n)); + assert_eq!(uk, BigUint::from(p3qm1_val % u64::from(m))); + } + } + + fn lucasm_naive(p: usize, q: isize, m: u16, n: u16) -> (u16, u16) { + if n == 0 { + return (0, 2); + } + + let m = m as usize; + let q = q.absm(&m); + let (mut um1, mut u) = (0, 1); // U_{n-1}, U_{n} + let (mut vm1, mut v) = (2, p % m); // V_{n-1}, V_{n} + + for _ in 1..n { + let new_u = p.mulm(u, &m).subm(q.mulm(um1, &m), &m); + um1 = u; + u = new_u; + + let new_v = p.mulm(v, &m).subm(q.mulm(vm1, &m), &m); + vm1 = v; + v = new_v; + } + (u as u16, v as u16) + } + for _ in 0..10 { + let n = u16::from(random::()); + let m = random::(); + let p = random::() as usize; + let q = random::() as isize; + assert_eq!( + LucasUtils::lucasm(p, q, m, n), + lucasm_naive(p, q, m, n), + "failed with Lucas settings: p={p}, q={q}, m={m}, n={n}" + ); + } + } + + #[test] + fn lucas_prp_test() { + // Some known cases + assert!(19u8.is_lprp(Some(3), Some(-1))); + assert!(5u8.is_lprp(None, None)); + assert!(7u8.is_lprp(None, None)); + assert!(!9u8.is_lprp(None, None)); + assert!(!5719u16.is_lprp(None, None)); + assert!(!1239u16.is_eslprp(None)); + + // least lucas pseudo primes for Q=-1 and Jacobi(D/n) = -1 (from Wikipedia) + let plimit: [u16; 5] = [323, 35, 119, 9, 9]; + for (i, l) in plimit.iter().copied().enumerate() { + let p = i + 1; + assert!(l.is_lprp(Some(p), Some(-1))); + + // test four random numbers under limit + for _ in 0..10 { + let n = random::() % l; + if n <= 3 || n.is_sprp(2) { + continue; + } // skip real primes + let d = (p * p + 4) as u16; + if n.is_odd() && d.jacobi(&n) != -1 { + continue; + } + assert!( + !n.is_lprp(Some(p), Some(-1)), + "lucas prp test on {} with p = {}", + n, + p + ); + } + } + + // least strong lucas pseudoprimes for Q=-1 and Jacobi(D/n) = -1 (from Wikipedia) + let plimit: [u16; 3] = [4181, 169, 119]; + for (i, l) in plimit.iter().copied().enumerate() { + let p = i + 1; + assert!(l.is_slprp(Some(p), Some(-1))); + + // test random numbers under limit + for _ in 0..10 { + let n = random::() % l; + if n <= 3 || (n.is_sprp(2) && n.is_sprp(3)) { + continue; + } // skip real primes + let d = (p * p + 4) as u16; + if n.is_odd() && d.jacobi(&n) != -1 { + continue; + } + assert!( + !n.is_slprp(Some(p), Some(-1)), + "strong lucas prp test on {} with p = {}", + n, + p + ); + } + } + + // lucas pseudoprimes (OEIS:A217120) under 10000 + let lpsp: [u16; 9] = [323, 377, 1159, 1829, 3827, 5459, 5777, 9071, 9179]; + for psp in lpsp { + assert!( + psp.is_lprp(None, None), + "lucas prp test on pseudoprime {}", + psp + ); + } + for _ in 0..50 { + let n = random::() % 10000; + if n <= 3 || (n.is_sprp(2) && n.is_sprp(3)) { + continue; + } // skip real primes + if lpsp.iter().any(|x| x == &n) { + continue; + } // skip pseudoprimes + assert!(!n.is_lprp(None, None), "lucas prp test on {}", n); + } + + // strong lucas pseudoprimes (OEIS:A217255) under 10000 + let slpsp: [u16; 2] = [5459, 5777]; + for psp in slpsp { + assert!( + psp.is_slprp(None, None), + "strong lucas prp test on pseudoprime {}", + psp + ); + } + for _ in 0..50 { + let n = random::() % 10000; + if n <= 3 || (n.is_sprp(2) && n.is_sprp(3)) { + continue; + } // skip real primes + if slpsp.iter().any(|x| x == &n) { + continue; + } // skip pseudoprimes + assert!(!n.is_slprp(None, None), "strong lucas prp test on {}", n); + } + + // extra strong lucas pseudoprimes (OEIS:A217719) under 10000 + let eslpsp: [u16; 3] = [989, 3239, 5777]; + for psp in eslpsp { + assert!( + psp.is_eslprp(None), + "extra strong lucas prp test on pseudoprime {}", + psp + ); + } + for _ in 0..50 { + let n = random::() % 10000; + if n <= 3 || (n.is_sprp(2) && n.is_sprp(3)) { + continue; + } // skip real primes + if eslpsp.iter().any(|x| x == &n) { + continue; + } // skip pseudoprimes + assert!(!n.is_eslprp(None), "extra strong lucas prp test on {}", n); + } + } +} diff --git a/vendor/num-prime/src/rand.rs b/vendor/num-prime/src/rand.rs new file mode 100644 index 0000000..aa0ac59 --- /dev/null +++ b/vendor/num-prime/src/rand.rs @@ -0,0 +1,349 @@ +use crate::mint::SmallMint; +use crate::nt_funcs::{is_prime, is_prime64, next_prime}; +use crate::{PrimalityTestConfig, RandPrime}; +#[cfg(feature = "big-int")] +use num_bigint::{BigUint, RandBigInt}; +use rand::Rng; + +macro_rules! impl_randprime_prim { + ($($T:ty)*) => {$( + impl RandPrime<$T> for R { + #[inline] + fn gen_prime(&mut self, bit_size: usize, _: Option) -> $T { + if bit_size > (<$T>::BITS as usize) { + panic!("The given bit size limit exceeded the capacity of the integer type!") + } + // Below two bits there is no prime to return within the width. + assert!(bit_size >= 2, "The given bit size is too small to hold a prime!"); + + loop { + let t: $T = self.gen(); + let t = (t >> (<$T>::BITS - bit_size as u32)) | 1; // filter even numbers + if is_prime64(t as u64) { + break t + } else if let Some(p) = next_prime(&t, None) { + // deterministic primality test will be used for integers under u64 + // next_prime can step past the requested width -- for 12 bits, + // 4095 gives 4099 -- so draw again rather than widen. + if bit_size as u32 == <$T>::BITS || p >> (bit_size as u32) == 0 { + break p + } + } + } + } + + #[inline] + fn gen_prime_exact(&mut self, bit_size: usize, _: Option) -> $T { + if bit_size > (<$T>::BITS as usize) { + panic!("The given bit size limit exceeded the capacity of the integer type!") + } + // Below two bits there is no prime to return within the width. + assert!(bit_size >= 2, "The given bit size is too small to hold a prime!"); + + loop { + let t: $T = self.gen(); + let t = (t >> (<$T>::BITS - bit_size as u32)) | 1 | (1 << (bit_size - 1)); + if is_prime64(t as u64) { + break t + } else if let Some(p) = next_prime(&t, None) { + // deterministic primality test will be used for integers under u64 + // next_prime can step past the requested width -- for 12 bits, + // 4095 gives 4099 -- so draw again rather than widen. + if bit_size as u32 == <$T>::BITS || p >> (bit_size as u32) == 0 { + break p + } + } + } + } + + #[inline] + fn gen_safe_prime(&mut self, bit_size: usize) -> $T { + loop { + // deterministic primality test will be used for integers under u64 + let p = self.gen_prime(bit_size, None); + + // test (p-1)/2 + if is_prime64((p >> 1) as u64) { + break p + } + // test 2p+1 + if let Some(p2) = p.checked_mul(2).and_then(|v| v.checked_add(1)) { + if is_prime64(p2 as u64) { + break p2 + } + } + } + } + + #[inline] + fn gen_safe_prime_exact(&mut self, bit_size: usize) -> $T { + loop { + // deterministic primality test will be used for integers under u64 + let p: $T = self.gen_prime_exact(bit_size, None); + + // test (p-1)/2 + if is_prime64((p >> 1) as u64) { + break p + } + } + } + } + )*} +} +impl_randprime_prim!(u8 u16 u32 u64); + +impl RandPrime for R { + #[inline] + fn gen_prime(&mut self, bit_size: usize, config: Option) -> u128 { + assert!( + bit_size <= (u128::BITS as usize), + "The given bit size limit exceeded the capacity of the integer type!" + ); + // Below two bits there is no prime to return within the width. + assert!( + bit_size >= 2, + "The given bit size is too small to hold a prime!" + ); + + loop { + let t: u128 = self.gen(); + let t = (t >> (u128::BITS - bit_size as u32)) | 1; // filter even numbers + if is_prime(&SmallMint::from(t), config).probably() { + break t; + } else if let Some(p) = next_prime(&t, None) { + // deterministic primality test will be used for integers under u64 + // next_prime can step past the requested width; draw again if it did. + if bit_size as u32 == u128::BITS || p >> (bit_size as u32) == 0 { + break p; + } + } + } + } + + #[inline] + fn gen_prime_exact(&mut self, bit_size: usize, config: Option) -> u128 { + assert!( + bit_size <= (u128::BITS as usize), + "The given bit size limit exceeded the capacity of the integer type!" + ); + // Below two bits there is no prime to return within the width. + assert!( + bit_size >= 2, + "The given bit size is too small to hold a prime!" + ); + + loop { + let t: u128 = self.gen(); + let t = (t >> (u128::BITS - bit_size as u32)) | 1 | (1 << (bit_size - 1)); + if is_prime(&SmallMint::from(t), config).probably() { + break t; + } else if let Some(p) = next_prime(&t, None) { + // deterministic primality test will be used for integers under u64 + // next_prime can step past the requested width; draw again if it did. + if bit_size as u32 == u128::BITS || p >> (bit_size as u32) == 0 { + break p; + } + } + } + } + + #[inline] + fn gen_safe_prime(&mut self, bit_size: usize) -> u128 { + loop { + let config = Some(PrimalityTestConfig::strict()); + let p = self.gen_prime(bit_size, config); + if is_prime(&SmallMint::from(p >> 1), config).probably() { + break p; + } + if let Some(p2) = p.checked_mul(2).and_then(|v| v.checked_add(1)) { + if is_prime(&p2, config).probably() { + break p2; + } + } + } + } + + #[inline] + fn gen_safe_prime_exact(&mut self, bit_size: usize) -> u128 { + loop { + let config = Some(PrimalityTestConfig::strict()); + let p = self.gen_prime_exact(bit_size, config); + if is_prime(&SmallMint::from(p >> 1), config).probably() { + break p; + } + } + } +} + +#[cfg(feature = "big-int")] +impl RandPrime for R { + #[inline] + fn gen_prime(&mut self, bit_size: usize, config: Option) -> BigUint { + // Below two bits there is no prime to return within the width. + assert!( + bit_size >= 2, + "The given bit size is too small to hold a prime!" + ); + loop { + let mut t = self.gen_biguint(bit_size as u64); + t.set_bit(0, true); // filter even numbers + if is_prime(&t, config).probably() { + break t; + } else if let Some(p) = next_prime(&t, config) { + // next_prime can step past the requested width; draw again if it did. + if p.bits() <= bit_size as u64 { + break p; + } + } + } + } + + #[inline] + fn gen_prime_exact(&mut self, bit_size: usize, config: Option) -> BigUint { + // Below two bits there is no prime to return within the width. + assert!( + bit_size >= 2, + "The given bit size is too small to hold a prime!" + ); + loop { + let mut t = self.gen_biguint(bit_size as u64); + t.set_bit(0, true); // filter even numbers + t.set_bit(bit_size as u64 - 1, true); + if is_prime(&t, config).probably() { + break t; + } else if let Some(p) = next_prime(&t, config) { + // next_prime can step past the requested width; draw again if it did. + if p.bits() <= bit_size as u64 { + break p; + } + } + } + } + + #[inline] + fn gen_safe_prime(&mut self, bit_size: usize) -> BigUint { + let config = Some(PrimalityTestConfig::strict()); + let p = self.gen_prime(bit_size, config); + if is_prime(&(&p >> 1u8), config).probably() { + return p; + } + let p2 = (p << 1u8) + 1u8; + if is_prime(&p2, config).probably() { + return p2; + } + + self.gen_safe_prime(bit_size) + } + + #[inline] + fn gen_safe_prime_exact(&mut self, bit_size: usize) -> BigUint { + let config = Some(PrimalityTestConfig::strict()); + loop { + let p: BigUint = self.gen_prime_exact(bit_size, config); + if is_prime(&(&p >> 1u8), config).probably() { + return p; + } + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::nt_funcs::is_safe_prime; + + #[test] + fn rand_prime() { + let mut rng = rand::thread_rng(); + + // test random prime generation for each size + let p: u8 = rng.gen_prime(8, None); + assert!(is_prime64(u64::from(p))); + let p: u16 = rng.gen_prime(16, None); + assert!(is_prime64(u64::from(p))); + let p: u32 = rng.gen_prime(32, None); + assert!(is_prime64(u64::from(p))); + let p: u64 = rng.gen_prime(64, None); + assert!(is_prime64(p)); + let p: u128 = rng.gen_prime(128, None); + assert!(is_prime(&p, None).probably()); + + // test random safe prime generation + let p: u8 = rng.gen_safe_prime(8); + assert!(is_safe_prime(&p).probably()); + let p: u32 = rng.gen_safe_prime(32); + assert!(is_safe_prime(&p).probably()); + let p: u128 = rng.gen_safe_prime(128); + assert!(is_safe_prime(&p).probably()); + + #[cfg(feature = "big-int")] + { + let p: BigUint = rng.gen_prime(512, None); + assert!(is_prime(&p, None).probably()); + let p: BigUint = rng.gen_safe_prime(192); + assert!(is_safe_prime(&p).probably()); + } + + // test bit size limit + let p: u16 = rng.gen_prime(12, None); + assert!(p < (1 << 12)); + let p: u32 = rng.gen_prime(24, None); + assert!(p < (1 << 24)); + } + + /// `next_prime` steps past the requested width once in every 2048 odd + /// draws at 12 bits -- 4095 gives 4099 -- which is rare enough that the + /// bound assertions above reached CI as a flake rather than a failure. + /// Draw enough times to make the boundary a certainty instead. + #[test] + fn rand_prime_stays_within_the_bit_size() { + let mut rng = rand::thread_rng(); + for _ in 0..50_000 { + let p: u16 = rng.gen_prime(12, None); + assert!(p < (1 << 12), "{} is wider than 12 bits", p); + let p: u16 = rng.gen_prime_exact(12, None); + assert!( + (1 << 11..1 << 12).contains(&p), + "{} is not exactly 12 bits", + p + ); + } + } + + #[test] + fn rand_prime_exact() { + let mut rng = rand::thread_rng(); + + // test exact size prime generation + let p: u8 = rng.gen_prime_exact(8, None); + assert!(is_prime64(u64::from(p))); + assert_eq!(p.leading_zeros(), 0); + let p: u32 = rng.gen_prime_exact(32, None); + assert!(is_prime64(u64::from(p))); + assert_eq!(p.leading_zeros(), 0); + let p: u128 = rng.gen_prime_exact(128, None); + assert!(is_prime(&p, None).probably()); + assert_eq!(p.leading_zeros(), 0); + + // test random safe prime generation + let p: u8 = rng.gen_safe_prime_exact(8); + assert!(is_safe_prime(&p).probably()); + assert_eq!(p.leading_zeros(), 0); + let p: u32 = rng.gen_safe_prime_exact(32); + assert!(is_safe_prime(&p).probably()); + assert_eq!(p.leading_zeros(), 0); + let p: u128 = rng.gen_safe_prime_exact(128); + assert!(is_safe_prime(&p).probably()); + assert_eq!(p.leading_zeros(), 0); + + #[cfg(feature = "big-int")] + { + let p: BigUint = rng.gen_prime_exact(192, None); + assert!(is_prime(&p, None).probably()); + assert_eq!(p.bits(), 192); + let p: BigUint = rng.gen_safe_prime_exact(192); + assert!(is_safe_prime(&p).probably()); + assert_eq!(p.bits(), 192); + } + } +} diff --git a/vendor/num-prime/src/splitmix64.rs b/vendor/num-prime/src/splitmix64.rs new file mode 100644 index 0000000..cd6621c --- /dev/null +++ b/vendor/num-prime/src/splitmix64.rs @@ -0,0 +1,61 @@ +//! SplitMix64 pseudorandom number generator. +//! +//! Used to draw the Pollard's rho start and offset values. It is seeded from +//! the number being factored, so factoring a number does the same work on +//! every call, whatever was factored before. +//! +//! Algorithm from Steele, Lea and Flood, "Fast splittable pseudorandom number +//! generators", OOPSLA 2014 (), +//! following Sebastiano Vigna's reference implementation +//! (). + +/// SplitMix64 generator. Not suitable for cryptographic use. +pub(crate) struct SplitMix64(u64); + +impl SplitMix64 { + pub(crate) fn new(seed: u64) -> Self { + Self(seed) + } + + pub(crate) fn next_u64(&mut self) -> u64 { + self.0 = self.0.wrapping_add(0x9e37_79b9_7f4a_7c15); + let mut z = self.0; + z = (z ^ (z >> 30)).wrapping_mul(0xbf58_476d_1ce4_e5b9); + z = (z ^ (z >> 27)).wrapping_mul(0x94d0_49bb_1331_11eb); + z ^ (z >> 31) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn reference_values() { + // outputs of the reference implementation + let mut rng = SplitMix64::new(1_234_567); + let expected = [ + 6_457_827_717_110_365_317, + 3_203_168_211_198_807_973, + 9_817_491_932_198_370_423, + 4_593_380_528_125_082_431, + 16_408_922_859_458_223_821, + ]; + for e in expected { + assert_eq!(rng.next_u64(), e); + } + assert_eq!(SplitMix64::new(0).next_u64(), 0xe220_a839_7b1d_cdaf); + } + + #[test] + fn reproducible() { + let draw = |seed| { + let mut rng = SplitMix64::new(seed); + (0..8).map(|_| rng.next_u64()).collect::>() + }; + let first = draw(42); + assert_eq!(first, draw(42)); + assert_ne!(first, draw(43)); + assert_ne!(first[0], first[1]); + } +} diff --git a/vendor/num-prime/src/tables.rs b/vendor/num-prime/src/tables.rs new file mode 100644 index 0000000..9685d85 --- /dev/null +++ b/vendor/num-prime/src/tables.rs @@ -0,0 +1,17911 @@ +//////////////////// Known small primes //////////////////// +// The prime table here is used for prime buffer initialization, and also used +// for trivial division in integer factorization and moebius mu function + +// only list primes to 256 if big-table feature is disabled +/// A static table of small primes +#[cfg(not(feature = "big-table"))] +pub const SMALL_PRIMES: [u8; 54] = [ + 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, + 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, + 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, +]; +/// Next prime of the last one in SMALL_PRIMES +#[cfg(not(feature = "big-table"))] +pub const SMALL_PRIMES_NEXT: u64 = 257; + +// list 1024 primes if big-table feature is enabled +/// A static table of small primes +#[cfg(feature = "big-table")] +pub const SMALL_PRIMES: [u16; 1024] = [ + 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, + 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, + 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, + 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, + 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, + 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, + 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, + 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, + 937, 941, 947, 953, 967, 971, 977, 983, 991, 997, 1009, 1013, 1019, 1021, 1031, 1033, 1039, + 1049, 1051, 1061, 1063, 1069, 1087, 1091, 1093, 1097, 1103, 1109, 1117, 1123, 1129, 1151, 1153, + 1163, 1171, 1181, 1187, 1193, 1201, 1213, 1217, 1223, 1229, 1231, 1237, 1249, 1259, 1277, 1279, + 1283, 1289, 1291, 1297, 1301, 1303, 1307, 1319, 1321, 1327, 1361, 1367, 1373, 1381, 1399, 1409, + 1423, 1427, 1429, 1433, 1439, 1447, 1451, 1453, 1459, 1471, 1481, 1483, 1487, 1489, 1493, 1499, + 1511, 1523, 1531, 1543, 1549, 1553, 1559, 1567, 1571, 1579, 1583, 1597, 1601, 1607, 1609, 1613, + 1619, 1621, 1627, 1637, 1657, 1663, 1667, 1669, 1693, 1697, 1699, 1709, 1721, 1723, 1733, 1741, + 1747, 1753, 1759, 1777, 1783, 1787, 1789, 1801, 1811, 1823, 1831, 1847, 1861, 1867, 1871, 1873, + 1877, 1879, 1889, 1901, 1907, 1913, 1931, 1933, 1949, 1951, 1973, 1979, 1987, 1993, 1997, 1999, + 2003, 2011, 2017, 2027, 2029, 2039, 2053, 2063, 2069, 2081, 2083, 2087, 2089, 2099, 2111, 2113, + 2129, 2131, 2137, 2141, 2143, 2153, 2161, 2179, 2203, 2207, 2213, 2221, 2237, 2239, 2243, 2251, + 2267, 2269, 2273, 2281, 2287, 2293, 2297, 2309, 2311, 2333, 2339, 2341, 2347, 2351, 2357, 2371, + 2377, 2381, 2383, 2389, 2393, 2399, 2411, 2417, 2423, 2437, 2441, 2447, 2459, 2467, 2473, 2477, + 2503, 2521, 2531, 2539, 2543, 2549, 2551, 2557, 2579, 2591, 2593, 2609, 2617, 2621, 2633, 2647, + 2657, 2659, 2663, 2671, 2677, 2683, 2687, 2689, 2693, 2699, 2707, 2711, 2713, 2719, 2729, 2731, + 2741, 2749, 2753, 2767, 2777, 2789, 2791, 2797, 2801, 2803, 2819, 2833, 2837, 2843, 2851, 2857, + 2861, 2879, 2887, 2897, 2903, 2909, 2917, 2927, 2939, 2953, 2957, 2963, 2969, 2971, 2999, 3001, + 3011, 3019, 3023, 3037, 3041, 3049, 3061, 3067, 3079, 3083, 3089, 3109, 3119, 3121, 3137, 3163, + 3167, 3169, 3181, 3187, 3191, 3203, 3209, 3217, 3221, 3229, 3251, 3253, 3257, 3259, 3271, 3299, + 3301, 3307, 3313, 3319, 3323, 3329, 3331, 3343, 3347, 3359, 3361, 3371, 3373, 3389, 3391, 3407, + 3413, 3433, 3449, 3457, 3461, 3463, 3467, 3469, 3491, 3499, 3511, 3517, 3527, 3529, 3533, 3539, + 3541, 3547, 3557, 3559, 3571, 3581, 3583, 3593, 3607, 3613, 3617, 3623, 3631, 3637, 3643, 3659, + 3671, 3673, 3677, 3691, 3697, 3701, 3709, 3719, 3727, 3733, 3739, 3761, 3767, 3769, 3779, 3793, + 3797, 3803, 3821, 3823, 3833, 3847, 3851, 3853, 3863, 3877, 3881, 3889, 3907, 3911, 3917, 3919, + 3923, 3929, 3931, 3943, 3947, 3967, 3989, 4001, 4003, 4007, 4013, 4019, 4021, 4027, 4049, 4051, + 4057, 4073, 4079, 4091, 4093, 4099, 4111, 4127, 4129, 4133, 4139, 4153, 4157, 4159, 4177, 4201, + 4211, 4217, 4219, 4229, 4231, 4241, 4243, 4253, 4259, 4261, 4271, 4273, 4283, 4289, 4297, 4327, + 4337, 4339, 4349, 4357, 4363, 4373, 4391, 4397, 4409, 4421, 4423, 4441, 4447, 4451, 4457, 4463, + 4481, 4483, 4493, 4507, 4513, 4517, 4519, 4523, 4547, 4549, 4561, 4567, 4583, 4591, 4597, 4603, + 4621, 4637, 4639, 4643, 4649, 4651, 4657, 4663, 4673, 4679, 4691, 4703, 4721, 4723, 4729, 4733, + 4751, 4759, 4783, 4787, 4789, 4793, 4799, 4801, 4813, 4817, 4831, 4861, 4871, 4877, 4889, 4903, + 4909, 4919, 4931, 4933, 4937, 4943, 4951, 4957, 4967, 4969, 4973, 4987, 4993, 4999, 5003, 5009, + 5011, 5021, 5023, 5039, 5051, 5059, 5077, 5081, 5087, 5099, 5101, 5107, 5113, 5119, 5147, 5153, + 5167, 5171, 5179, 5189, 5197, 5209, 5227, 5231, 5233, 5237, 5261, 5273, 5279, 5281, 5297, 5303, + 5309, 5323, 5333, 5347, 5351, 5381, 5387, 5393, 5399, 5407, 5413, 5417, 5419, 5431, 5437, 5441, + 5443, 5449, 5471, 5477, 5479, 5483, 5501, 5503, 5507, 5519, 5521, 5527, 5531, 5557, 5563, 5569, + 5573, 5581, 5591, 5623, 5639, 5641, 5647, 5651, 5653, 5657, 5659, 5669, 5683, 5689, 5693, 5701, + 5711, 5717, 5737, 5741, 5743, 5749, 5779, 5783, 5791, 5801, 5807, 5813, 5821, 5827, 5839, 5843, + 5849, 5851, 5857, 5861, 5867, 5869, 5879, 5881, 5897, 5903, 5923, 5927, 5939, 5953, 5981, 5987, + 6007, 6011, 6029, 6037, 6043, 6047, 6053, 6067, 6073, 6079, 6089, 6091, 6101, 6113, 6121, 6131, + 6133, 6143, 6151, 6163, 6173, 6197, 6199, 6203, 6211, 6217, 6221, 6229, 6247, 6257, 6263, 6269, + 6271, 6277, 6287, 6299, 6301, 6311, 6317, 6323, 6329, 6337, 6343, 6353, 6359, 6361, 6367, 6373, + 6379, 6389, 6397, 6421, 6427, 6449, 6451, 6469, 6473, 6481, 6491, 6521, 6529, 6547, 6551, 6553, + 6563, 6569, 6571, 6577, 6581, 6599, 6607, 6619, 6637, 6653, 6659, 6661, 6673, 6679, 6689, 6691, + 6701, 6703, 6709, 6719, 6733, 6737, 6761, 6763, 6779, 6781, 6791, 6793, 6803, 6823, 6827, 6829, + 6833, 6841, 6857, 6863, 6869, 6871, 6883, 6899, 6907, 6911, 6917, 6947, 6949, 6959, 6961, 6967, + 6971, 6977, 6983, 6991, 6997, 7001, 7013, 7019, 7027, 7039, 7043, 7057, 7069, 7079, 7103, 7109, + 7121, 7127, 7129, 7151, 7159, 7177, 7187, 7193, 7207, 7211, 7213, 7219, 7229, 7237, 7243, 7247, + 7253, 7283, 7297, 7307, 7309, 7321, 7331, 7333, 7349, 7351, 7369, 7393, 7411, 7417, 7433, 7451, + 7457, 7459, 7477, 7481, 7487, 7489, 7499, 7507, 7517, 7523, 7529, 7537, 7541, 7547, 7549, 7559, + 7561, 7573, 7577, 7583, 7589, 7591, 7603, 7607, 7621, 7639, 7643, 7649, 7669, 7673, 7681, 7687, + 7691, 7699, 7703, 7717, 7723, 7727, 7741, 7753, 7757, 7759, 7789, 7793, 7817, 7823, 7829, 7841, + 7853, 7867, 7873, 7877, 7879, 7883, 7901, 7907, 7919, 7927, 7933, 7937, 7949, 7951, 7963, 7993, + 8009, 8011, 8017, 8039, 8053, 8059, 8069, 8081, 8087, 8089, 8093, 8101, 8111, 8117, 8123, 8147, + 8161, // 8167, 8171, 8179, 8191 +]; + +/// Next prime of the last one in `SMALL_PRIMES` +#[cfg(feature = "big-table")] +pub const SMALL_PRIMES_NEXT: u64 = 8167; + +//////////////////// Pre-computed inversions for primes //////////////////// +#[cfg(feature = "big-table")] +type P64 = num_modular::PreModInv; + +/// Precomputed modular inverse for fast divisibility check +/// +/// Note that the factor 2 should be eliminated before checking the primes +#[rustfmt::skip] +#[cfg(feature = "big-table")] +pub const SMALL_PRIMES_INV: [P64; 1024] = [ + // the first should be 2, but 2 has not modular inverse + P64::new(0x0000_0000_0000_0001, 0xffff_ffff_ffff_ffff), + P64::new(0xaaaa_aaaa_aaaa_aaab, 0x5555_5555_5555_5555), + P64::new(0xcccc_cccc_cccc_cccd, 0x3333_3333_3333_3333), + P64::new(0x6db6_db6d_b6db_6db7, 0x2492_4924_9249_2492), + P64::new(0x2e8b_a2e8_ba2e_8ba3, 0x1745_d174_5d17_45d1), + P64::new(0x4ec4_ec4e_c4ec_4ec5, 0x13b1_3b13_b13b_13b1), + P64::new(0xf0f0_f0f0_f0f0_f0f1, 0x0f0f_0f0f_0f0f_0f0f), + P64::new(0x86bc_a1af_286b_ca1b, 0x0d79_435e_50d7_9435), + P64::new(0xd37a_6f4d_e9bd_37a7, 0x0b21_642c_8590_b216), + P64::new(0x34f7_2c23_4f72_c235, 0x08d3_dcb0_8d3d_cb08), + P64::new(0xef7b_def7_bdef_7bdf, 0x0842_1084_2108_4210), + P64::new(0x14c1_bacf_914c_1bad, 0x06eb_3e45_306e_b3e4), + P64::new(0x8f9c_18f9_c18f_9c19, 0x063e_7063_e706_3e70), + P64::new(0x82fa_0be8_2fa0_be83, 0x05f4_17d0_5f41_7d05), + P64::new(0x51b3_bea3_677d_46cf, 0x0572_620a_e4c4_15c9), + P64::new(0x21cf_b2b7_8c13_521d, 0x04d4_873e_cade_304d), + P64::new(0xcbee_a4e1_a08a_d8f3, 0x0456_c797_dd49_c341), + P64::new(0x4fbc_da3a_c10c_9715, 0x0432_5c53_ef36_8eb0), + P64::new(0xf0b7_672a_07a4_4c6b, 0x03d2_2635_7e16_ece5), + P64::new(0x193d_4bb7_e327_a977, 0x039b_0ad1_2073_615a), + P64::new(0x7e3f_1f8f_c7e3_f1f9, 0x0381_c0e0_7038_1c0e), + P64::new(0x9b8b_577e_6137_16af, 0x033d_91d2_a206_7b23), + P64::new(0xa378_4a06_2b2e_43db, 0x0315_9721_ed7e_7534), + P64::new(0xf47e_8fd1_fa3f_47e9, 0x02e0_5c0b_8170_2e05), + P64::new(0xa3a0_fd5c_5f02_a3a1, 0x02a3_a0fd_5c5f_02a3), + P64::new(0x3a4c_0a23_7c32_b16d, 0x0288_df0c_ac5b_3f5d), + P64::new(0xdab7_ec1d_d343_1b57, 0x027c_4597_9c95_204f), + P64::new(0x77a0_4c8f_8d28_ac43, 0x0264_7c69_4562_17ec), + P64::new(0xa6c0_964f_da6c_0965, 0x0259_3f69_b025_93f6), + P64::new(0x90fd_bc09_0fdb_c091, 0x0243_f6f0_243f_6f02), + P64::new(0x7efd_fbf7_efdf_bf7f, 0x0204_0810_2040_8102), + P64::new(0x03e8_8cb3_c948_4e2b, 0x01f4_4659_e4a4_2715), + P64::new(0xe21a_291c_0779_75b9, 0x01de_5d6e_3f88_68a4), + P64::new(0x3aef_6ca9_7058_6723, 0x01d7_7b65_4b82_c339), + P64::new(0xdf5b_0f76_8ce2_cabd, 0x01b7_d6c3_dda3_38b2), + P64::new(0x6fe4_dfc9_bf93_7f27, 0x01b2_0364_06c8_0d90), + P64::new(0x5b4f_e5e9_2c06_85b5, 0x01a1_6d3f_97a4_b01a), + P64::new(0x1f69_3a1c_451a_b30b, 0x0192_0fb4_9d0e_228d), + P64::new(0x8d07_aa27_db35_a717, 0x0188_6e5f_0abb_0499), + P64::new(0x8823_83b3_0d51_6325, 0x017a_d220_8e0e_cc35), + P64::new(0xed68_66f8_d962_ae7b, 0x016e_1f76_b433_7c6c), + P64::new(0x3454_dca4_10f8_ed9d, 0x016a_13cd_1537_2904), + P64::new(0x1d7c_a632_ee93_6f3f, 0x0157_1ed3_c506_b39a), + P64::new(0x70bf_0153_9094_8f41, 0x0153_9094_8f40_feac), + P64::new(0xc96b_db9d_3d13_7e0d, 0x014c_ab88_725a_f6e7), + P64::new(0x2697_cc8a_ef46_c0f7, 0x0149_539e_3b2d_066e), + P64::new(0xc0e8_f2a7_6e68_575b, 0x0136_98df_3de0_7479), + P64::new(0x6877_63df_db43_bb1f, 0x0125_e227_0809_2f11), + P64::new(0x1b10_ea92_9ba1_44cb, 0x0120_b470_c67c_0d88), + P64::new(0x1d10_c4c0_478b_bced, 0x011e_2ef3_b3fb_8744), + P64::new(0x63fb_9aeb_1fdc_d759, 0x0119_4538_08ca_29c0), + P64::new(0x64af_aa4f_437b_2e0f, 0x0112_358e_75d3_0336), + P64::new(0xf010_fef0_10fe_f011, 0x010f_ef01_0fef_010f), + P64::new(0x28cb_fbeb_9a02_0a33, 0x0105_197f_7d73_4041), + P64::new(0xff00_ff00_ff00_ff01, 0x00ff_00ff_00ff_00ff), + P64::new(0xd624_fd14_70e9_9cb7, 0x00f9_2fb2_2118_55a8), + P64::new(0x8fb3_ddbd_6205_b5c5, 0x00f3_a0d5_2cba_8723), + P64::new(0xd57d_a36c_a27a_cdef, 0x00f1_d48b_cee0_d399), + P64::new(0xee70_c03b_25e4_463d, 0x00ec_9791_18f3_fc4d), + P64::new(0xc5b1_a6b8_0749_cb29, 0x00e9_3965_1fe2_d8d3), + P64::new(0x4776_8073_c9b9_7113, 0x00e7_9372_e225_fe30), + P64::new(0x2591_e948_84ce_32ad, 0x00df_ac1f_7434_6c57), + P64::new(0xf028_06ab_c74b_e1fb, 0x00d5_78e9_7c3f_5fe5), + P64::new(0x7ec3_e8f3_a719_8487, 0x00d2_ba08_3b44_5250), + P64::new(0x5855_0f8a_3940_9d09, 0x00d1_6154_3e28_e502), + P64::new(0xec9e_48ae_6f71_de15, 0x00ce_bcf8_bb5b_4169), + P64::new(0x2ff3_a018_bfce_8063, 0x00c5_fe74_0317_f9d0), + P64::new(0x7f9e_c3fc_f61f_e7b1, 0x00c2_7806_13c0_309e), + P64::new(0x89f5_abe5_70e0_46d3, 0x00bc_dd53_5db1_cc5b), + P64::new(0xda97_1b23_f154_5af5, 0x00bb_c840_8cd6_3069), + P64::new(0x79d5_f00b_9a78_62a1, 0x00b9_a786_2a0f_f465), + P64::new(0x4dba_1df3_2a12_8a57, 0x00b6_8d31_340e_4307), + P64::new(0x8753_0217_b774_7d8f, 0x00b2_927c_29da_5519), + P64::new(0x30ba_ae53_bb5e_06dd, 0x00af_b321_a149_6fdf), + P64::new(0xee70_206c_12e9_b5b3, 0x00ac_eb0f_891e_6551), + P64::new(0xcdde_9462_ec9d_be7f, 0x00ab_1cbd_d3e2_970f), + P64::new(0xafb6_4b05_ec41_cf4d, 0x00a8_7917_088e_262b), + P64::new(0x0294_4ff5_aec0_2945, 0x00a5_13fd_6bb0_0a51), + P64::new(0x2cb0_3312_8382_df71, 0x00a3_6e71_a2cb_0331), + P64::new(0x1cca_cc0c_84b1_c2a9, 0x00a0_3c16_8873_2b30), + P64::new(0x19a9_3db5_75eb_3a0b, 0x009c_6916_9b30_446d), + P64::new(0xcebe_ef94_fa86_fe2d, 0x009b_aade_8e4a_2f6e), + P64::new(0x6faa_77fb_3f8d_f54f, 0x0098_0e41_5620_1301), + P64::new(0x68a5_8af0_0975_a751, 0x0097_5a75_0ff6_8a58), + P64::new(0xd56e_36d0_c3ef_ac07, 0x0095_48e4_979e_0829), + P64::new(0xd8b4_4c47_a829_9b73, 0x0093_efd1_c50e_726b), + P64::new(0x02d9_ccaf_9ba7_0e41, 0x0091_f5bc_b8bb_02d9), + P64::new(0x0985_e1c0_23d9_e879, 0x008f_67a1_e3fd_c261), + P64::new(0x2a34_3316_c494_d305, 0x008e_2917_e0e7_02c6), + P64::new(0x70cb_7916_ab67_652f, 0x008d_8be3_3f95_d715), + P64::new(0xd398_f132_fb10_fe5b, 0x008c_5584_1c81_5ed5), + P64::new(0x6f2a_38a6_bf54_fa1f, 0x0088_d180_cd3a_4133), + P64::new(0x211d_f689_b98f_81d7, 0x0086_9222_b1ac_f1ce), + P64::new(0x0e99_4983_e90f_1ec3, 0x0085_797b_9177_65ab), + P64::new(0xad67_1e44_bed8_7f3b, 0x0083_55ac_e3c8_97db), + P64::new(0xf962_3a05_16e7_0fc7, 0x0082_4a4e_60b3_262b), + P64::new(0x4b71_29be_9dec_e355, 0x0080_c121_b28b_d1ba), + P64::new(0x190f_3b74_73f6_2c39, 0x007d_c9f3_397d_4c29), + P64::new(0x63da_cc9a_ad46_f9a3, 0x007d_4ece_8fe8_8139), + P64::new(0xc110_8fda_24e8_d035, 0x0079_237d_65bc_ce50), + P64::new(0xb775_7847_2319_bd8b, 0x0077_cf53_c5f7_936c), + P64::new(0x473d_20a1_c7ed_9da5, 0x0075_a8ac_cfbd_d11e), + P64::new(0xfbe8_5af0_fea2_c8fb, 0x0074_67ac_557c_228e), + P64::new(0x58a1_f7e6_ce0f_4c09, 0x0073_2d70_ed8d_b8e9), + P64::new(0x1a00_e58c_5449_86f3, 0x0072_c62a_24c3_797f), + P64::new(0x7194_a17f_55a1_0dc1, 0x0071_94a1_7f55_a10d), + P64::new(0x7084_9447_85e3_3763, 0x006f_a549_b41d_a7e7), + P64::new(0xba10_679b_d848_86b1, 0x006e_8419_e6f6_1221), + P64::new(0xebe9_c6bb_3126_0967, 0x006d_68b5_356c_207b), + P64::new(0x97a3_fe4b_d1ff_25e9, 0x006d_0b80_3685_c01b), + P64::new(0x6c63_8839_5b84_d99f, 0x006b_f790_a8b2_d207), + P64::new(0x8c51_da6a_1335_df6d, 0x006a_e907_ef4b_96c2), + P64::new(0x46f3_2344_75d5_add9, 0x006a_3799_1a23_aead), + P64::new(0x9056_05ca_3c61_9a43, 0x0069_dfbd_d429_5b66), + P64::new(0xcee8_dff3_0476_7747, 0x0067_dc4c_45c8_033e), + P64::new(0xff99_c27f_0066_3d81, 0x0066_3d80_ff99_c27f), + P64::new(0xacca_407f_671d_dc2b, 0x0065_ec17_e355_9948), + P64::new(0xe712_98ba_c1e1_2337, 0x0065_4ac8_35cf_ba5c), + P64::new(0xfa1e_9430_9cd0_9045, 0x0064_5c85_4ae1_0772), + P64::new(0xbebc_cb8e_9149_6b9b, 0x0063_7299_0e5f_901f), + P64::new(0x312f_a30c_c7d7_b8bd, 0x0063_2591_3c07_beef), + P64::new(0x6160_ff9e_9f00_6161, 0x0061_60ff_9e9f_0061), + P64::new(0x6b03_673b_5e28_152d, 0x0060_cdb5_20e5_e88e), + P64::new(0xfe80_2ffa_00bf_e803, 0x005f_f401_7fd0_05ff), + P64::new(0xe66f_e25c_9e90_7c7b, 0x005e_d79e_31a4_dccd), + P64::new(0x3f8b_236c_7652_8895, 0x005d_7d42_d48a_c5ef), + P64::new(0xf6f9_23bf_01ce_2c0d, 0x005c_6f35_ccba_5028), + P64::new(0x6c3d_3d98_bed7_c42f, 0x005b_2618_ec6a_d0a5), + P64::new(0x3098_1efc_d4b0_10e7, 0x005a_2553_748e_42e7), + P64::new(0x6f69_1fc8_1ebb_e575, 0x0059_686c_f744_cd5b), + P64::new(0xb104_80dd_b47b_52cb, 0x0058_ae97_bab7_9976), + P64::new(0x74cd_59ed_64f3_f0d7, 0x0058_345f_1876_865f), + P64::new(0x0105_cb81_316d_6c0f, 0x0057_43d5_bb24_795a), + P64::new(0x9be6_4c6d_91c1_195d, 0x0056_92c4_d1ab_74ab), + P64::new(0x71b3_f945_a27b_1f49, 0x0056_1e46_a4d5_f337), + P64::new(0x77d8_0d50_e508_fd01, 0x0055_38ed_0653_3997), + P64::new(0xa5eb_778e_1335_51cd, 0x0054_c807_f2c0_bec2), + P64::new(0x1865_7d3c_2d8a_3f1b, 0x0053_45ef_bc57_2d36), + P64::new(0x2e40_e220_c34a_d735, 0x0052_3a75_8f94_1345), + P64::new(0xa765_93c7_0a71_4919, 0x0051_0237_0f81_6c89), + P64::new(0x1eef_4521_24ee_a383, 0x0050_cf12_9fb9_4acf), + P64::new(0x3820_6dc2_42ba_771d, 0x004f_d319_41ca_fdd1), + P64::new(0x4cd4_c358_0777_2287, 0x004f_a170_4aa7_5945), + P64::new(0x83de_917d_5e69_ddf3, 0x004f_3ed6_d45a_63ad), + P64::new(0x882e_f040_3b4a_6c15, 0x004f_0de5_7154_ebed), + P64::new(0xf8fb_6c51_c606_b677, 0x004e_1cae_8815_f811), + P64::new(0xb4ab_aac4_46d3_e1fd, 0x004c_d47b_a5f6_ff19), + P64::new(0xa9f8_3bbe_484a_14e9, 0x004c_78ae_734d_f709), + P64::new(0x0beb_bc0d_1ce8_74d3, 0x004c_4b19_ed85_cfb8), + P64::new(0xbd41_8eaf_0473_189f, 0x004b_f093_221d_1218), + P64::new(0x44e3_af6f_372b_7e65, 0x004a_ba3c_21dc_633f), + P64::new(0xc87f_dace_4f9e_5d91, 0x004a_6360_c344_de00), + P64::new(0xec93_479c_446b_d9bb, 0x004a_383e_9f74_d68a), + P64::new(0xdac4_d592_e777_c647, 0x0049_e28f_babb_9940), + P64::new(0xa63e_a8c8_f61f_0c23, 0x0048_417b_57c7_8cd7), + P64::new(0xe476_062e_a5cb_bb6f, 0x0047_f043_713f_3a2b), + P64::new(0xdf68_761c_69da_ac27, 0x0047_4ff2_a102_81cf), + P64::new(0xb813_d737_637a_a061, 0x0046_8b6f_9a97_8f91), + P64::new(0xa3a7_7aac_1fb1_5099, 0x0045_f13f_1caf_f2e2), + P64::new(0x17f0_c3e0_712c_5825, 0x0045_a522_8cec_23e9), + P64::new(0xfd91_2a70_ff30_637b, 0x0045_342c_556c_66b9), + P64::new(0xfbb3_b5dc_0113_1289, 0x0044_c4a2_3fee_ced7), + P64::new(0x856d_560a_0f5a_cdf7, 0x0043_c5c2_0d3c_9fe6), + P64::new(0x9647_2f31_4d3f_89e3, 0x0043_7e49_4b23_9798), + P64::new(0xa76f_5c7e_d225_3531, 0x0043_142d_118e_47cb), + P64::new(0x816e_ae7c_7bf6_9fe7, 0x0042_ab5c_73a1_3458), + P64::new(0xb6a2_bea4_cfb1_781f, 0x0042_2195_0db0_f3db), + P64::new(0xa390_0c53_318e_81ed, 0x0041_bbb2_f80a_4553), + P64::new(0x60aa_7f5d_9f14_8d11, 0x0040_f391_612c_6680), + P64::new(0x6be8_c010_2c7a_505d, 0x0040_b1e9_4173_fefd), + P64::new(0x8ff3_f0ed_2872_8f33, 0x0040_5064_7d9d_0445), + P64::new(0x680e_0a87_e5ec_7155, 0x0040_3024_1b14_4f3b), + P64::new(0xbbf7_0fa4_9fe8_29b7, 0x003f_90c2_ab54_2cb1), + P64::new(0xd69d_1e7b_6a50_ca39, 0x003f_7141_2d59_f597), + P64::new(0x1a1e_0f46_b6d2_6aef, 0x003f_1377_01b9_8841), + P64::new(0x7429_f9a7_a825_1829, 0x003e_7988_6b60_e278), + P64::new(0xd9c2_219d_1b86_3613, 0x003e_5b19_16a7_181d), + P64::new(0x9140_6c18_20d0_77ad, 0x003d_c4a5_0968_f524), + P64::new(0x521f_4ec0_2e3d_2b97, 0x003d_a6e4_c955_0321), + P64::new(0xbb82_83b6_3dc8_eba5, 0x003d_4e4f_06f1_def3), + P64::new(0x431e_da15_3229_ebbf, 0x003c_4a6b_dd24_f9a4), + P64::new(0xaf0b_f78d_7e01_686b, 0x003c_11d5_4b52_5c73), + P64::new(0xa9ce_d074_2c08_6e8d, 0x003b_f5b1_c572_1065), + P64::new(0xc264_58ad_9f63_2df9, 0x003b_bdb9_862f_23b4), + P64::new(0xbbff_1255_dff8_92af, 0x003b_6a88_01db_5440), + P64::new(0xcbd4_9a33_3f04_d8fd, 0x003b_183c_f0fe_d886), + P64::new(0xec84_ed6f_9cfd_eff5, 0x003a_abe3_94bd_c3f4), + P64::new(0x9798_0cc4_0bda_9d4b, 0x003a_5ba3_e761_56da), + P64::new(0x777f_34d5_24f5_cbd9, 0x003a_0c3e_9533_78db), + P64::new(0x2797_051d_94cb_bb7f, 0x0038_f035_6132_0b1e), + P64::new(0xea76_9051_b4f4_3b81, 0x0038_d6ec_aef5_908a), + P64::new(0xce79_10f3_034d_4323, 0x0038_59cf_221e_6069), + P64::new(0x9279_1d13_74f5_b99b, 0x0037_f741_5dc9_588a), + P64::new(0x89a5_645c_c68e_a1b5, 0x0037_7df0_d390_2626), + P64::new(0x5f8a_acf7_96c0_cf0b, 0x0037_3622_1369_07fa), + P64::new(0xf2e9_0a15_e33e_df99, 0x0036_ef0c_3b39_b92f), + P64::new(0x8e99_e5fe_b897_c451, 0x0036_915f_47d5_5e6d), + P64::new(0xaca2_eda3_8fb9_1695, 0x0036_072c_f3f8_66fd), + P64::new(0x5d9b_737b_e5ea_8b41, 0x0035_d9b7_37be_5ea8), + P64::new(0x4aef_e1db_93fd_7cf7, 0x0035_9615_59cc_81c7), + P64::new(0xa099_4ef2_0b3f_8805, 0x0035_531c_897a_4592), + P64::new(0x1038_90bd_a912_822f, 0x0035_3cee_bd3e_98a4), + P64::new(0xb441_659d_13a9_147d, 0x0034_fad3_8158_5e5e), + P64::new(0x1e21_3444_0c4c_3f21, 0x0034_7884_d110_3130), + P64::new(0x263a_2772_7a68_83c3, 0x0034_0dd3_ac39_bf56), + P64::new(0x78e2_2147_2ab3_3855, 0x0033_51fd_fecc_140c), + P64::new(0x95ea_c88e_82e6_faff, 0x0033_3d72_b089_b524), + P64::new(0xf66c_2583_17be_8dab, 0x0033_148d_44d6_b261), + P64::new(0x09ee_202c_7cb9_1939, 0x0032_d7ae_f841_2458), + P64::new(0x8d2f_ca10_42a0_9ea3, 0x0032_c385_0e79_c0f1), + P64::new(0x8277_9c85_6d8b_8bf1, 0x0032_8766_d590_48a2), + P64::new(0x3879_361c_ba8a_223d, 0x0032_5fa1_8cb1_1833), + P64::new(0xf23f_4363_9c31_82a7, 0x0032_4bd6_5932_7e22), + P64::new(0xa038_68fc_474b_cd13, 0x0032_246e_7843_60f4), + P64::new(0x651e_78b8_c531_1a97, 0x0031_afa5_f1a3_3a08), + P64::new(0x8ffc_e639_c00c_6719, 0x0031_9c63_ff39_8e70), + P64::new(0xf7b4_6075_4b0b_61cf, 0x0031_62f7_519a_86a7), + P64::new(0x7b03_f335_9b8e_63b1, 0x0030_271f_c9d3_fc3c), + P64::new(0xa55c_5326_041e_b667, 0x002f_f104_ae89_750b), + P64::new(0x647f_88ab_896a_76f5, 0x002f_bb62_a236_d133), + P64::new(0x8fd9_7143_4a55_a46d, 0x002f_7499_7d20_70b4), + P64::new(0x9fbf_9699_5804_6447, 0x002e_d84a_a8b6_fce3), + P64::new(0x9986_feba_69be_3a81, 0x002e_832d_f7a4_6dbd), + P64::new(0xa668_b3e6_d053_796f, 0x002e_0e08_4685_7cab), + P64::new(0x9769_4e65_89f4_e09b, 0x002d_ecfb_dfb5_5ee6), + P64::new(0x3789_0c00_b772_1dbd, 0x002d_dc87_6f3f_f488), + P64::new(0x5ac0_94a2_35f3_7ea9, 0x002d_bbc1_d4c4_82c4), + P64::new(0x31cf_f775_f2d5_d65f, 0x002d_8af0_e0de_0556), + P64::new(0xddad_8e6b_3650_5217, 0x002d_4a7b_7d14_b30a), + P64::new(0x5a27_df89_7062_cd03, 0x002d_2a85_073b_cf4e), + P64::new(0xe239_6fe0_fdb5_a625, 0x002d_1a9a_b13e_8be4), + P64::new(0xb352_a495_7e82_317b, 0x002c_eb1e_b4b9_fd8b), + P64::new(0xd8ab_3f2c_60c2_ea3f, 0x002c_8d50_3a79_794c), + P64::new(0x6893_f702_f045_2479, 0x002c_404d_7087_84ed), + P64::new(0x9686_fdc1_82ac_f7e3, 0x002c_3106_6315_ec52), + P64::new(0x6854_0371_73dc_e12f, 0x002c_1297_d80f_2664), + P64::new(0x7f0d_ed16_85c2_7331, 0x002c_0370_44c5_5f6b), + P64::new(0xeeda_72e1_fe49_0b7d, 0x002b_e540_4cd1_3086), + P64::new(0x9e7b_fc95_9a8e_6e53, 0x002b_b845_adaf_0cce), + P64::new(0x49b3_14d6_d475_3dd7, 0x002b_5f62_c639_f16d), + P64::new(0x2e8f_8c5a_c4aa_1b3b, 0x002b_07e6_734f_2b88), + P64::new(0xb8ef_7234_8116_3d33, 0x002a_ce56_9d83_42b7), + P64::new(0x6a2e_c96a_5942_87b7, 0x002a_791d_5dbd_4dcf), + P64::new(0xdba4_1c6d_13aa_b8c5, 0x002a_4eff_8113_017c), + P64::new(0xc2ad_be64_8dc3_aaf1, 0x002a_3319_e156_df32), + P64::new(0x87a2_bade_565f_91a7, 0x002a_0986_2865_26ea), + P64::new(0x4d6f_e879_8c01_f5df, 0x0029_d295_51d9_1e39), + P64::new(0x3791_310c_8c23_d98b, 0x0029_b752_9e10_9f0a), + P64::new(0xf80e_446b_0122_8883, 0x0029_8137_491e_a465), + P64::new(0x9aed_1436_fbf5_00cf, 0x0029_665e_1eb9_f9da), + P64::new(0x7839_b54c_c8b2_4115, 0x0029_0975_2e01_9a5e), + P64::new(0xc128_c646_ad03_09c1, 0x0028_ef35_e2e5_efb0), + P64::new(0x14de_6316_24a3_c377, 0x0028_c815_aa4b_8278), + P64::new(0x3f7b_9fe6_8b0e_cbf9, 0x0028_bb1b_8671_99da), + P64::new(0x284f_fd75_ec00_a285, 0x0028_a13f_f5d7_b002), + P64::new(0x3780_3cb8_0dea_2ddb, 0x0028_7ab3_f173_e755), + P64::new(0x86b6_3f7c_9ac4_c6fd, 0x0028_6dea_d677_13bd), + P64::new(0x8b68_51d1_bd99_b9d3, 0x0028_47bf_cda6_503e), + P64::new(0xb62f_da77_ca34_3b6d, 0x0028_08c1_ea6b_4777), + P64::new(0x1f0d_c009_e343_83c9, 0x0027_8d0e_0f23_ff61), + P64::new(0x496d_c21d_dd35_b97f, 0x0027_6886_3c09_3c7f), + P64::new(0xb0e9_6ce1_7090_f82b, 0x0027_5051_15a7_3ca8), + P64::new(0xaadf_05ac_dd7d_024d, 0x0027_4441_a61d_c1b9), + P64::new(0xcb13_8196_746e_afb5, 0x0026_b5c1_6611_3cf0), + P64::new(0x347f_5237_3675_5d61, 0x0026_9e65_ad07_b18e), + P64::new(0xd14a_48a0_51f7_dd0b, 0x0026_92c2_5f87_7560), + P64::new(0x474d_71b1_ce91_4d25, 0x0026_58fa_7523_cd11), + P64::new(0x3860_63f5_e28c_1f89, 0x0026_1487_10cf_0f9e), + P64::new(0x1db7_325e_32d0_4e73, 0x0026_0936_3b22_524f), + P64::new(0xfef7_48d3_893b_880d, 0x0025_d106_5a1c_1122), + P64::new(0x2f33_5150_6e93_5605, 0x0025_a48a_382b_863f), + P64::new(0x7a36_37fa_2376_415b, 0x0025_8371_90ec_cdbc), + P64::new(0x4ac5_25d2_baa2_1969, 0x0025_6292_e95d_510c), + P64::new(0x3a11_c16b_42cd_351f, 0x0025_41ed_a98d_068c), + P64::new(0x6c7a_bde0_049c_2a11, 0x0024_e150_87fe_d8f5), + P64::new(0x54da_d030_3e06_9ac7, 0x0024_c18b_2097_9e5d), + P64::new(0xebf1_ac9f_dfe9_1433, 0x0024_ac7b_336d_e0c5), + P64::new(0xfafd_da82_37ce_c655, 0x0024_a1fc_478c_60bb), + P64::new(0xdce3_ff6e_71ff_b739, 0x0024_6380_1231_c009), + P64::new(0xbed5_737d_6286_db1b, 0x0024_300f_d506_ed33), + P64::new(0xe479_e431_fe08_b4df, 0x0023_f314_a494_da81), + P64::new(0x9dd9_b0dd_7742_f897, 0x0023_cade_dd2f_ad3a), + P64::new(0x8f09_d740_2c5a_5e87, 0x0023_7b7e_d266_4a03), + P64::new(0x9216_d5c4_d958_738d, 0x0023_3729_67db_af1d), + P64::new(0xb313_9ba1_1d34_ca63, 0x0023_1a30_8a37_1f20), + P64::new(0x47d5_4f7e_d644_afaf, 0x0023_06fa_63e1_e600), + P64::new(0x92a8_1d85_cf11_a1b1, 0x0022_fd67_3157_5684), + P64::new(0x754b_2653_3253_bdfd, 0x0022_ea50_7805_749c), + P64::new(0xbbe0_efc9_80bf_d467, 0x0022_e0cc_e8b3_d720), + P64::new(0xc0d8_d594_f024_dca1, 0x0022_b188_7857_d161), + P64::new(0x8238_d43b_caac_1a65, 0x0022_7977_fcc4_9cc0), + P64::new(0x2777_9c1f_ae61_75bb, 0x0022_5db3_7b5e_5f4f), + P64::new(0xa746_ca9a_f708_b2c9, 0x0022_421b_9132_2ed6), + P64::new(0x93f3_cd9f_389b_e823, 0x0021_f05b_35f5_2102), + P64::new(0x5cb4_a4c0_4c48_9345, 0x0021_e75d_e5c7_0d60), + P64::new(0xbf60_4774_3e85_b6b5, 0x0021_a01d_6c19_be96), + P64::new(0x61c1_4783_1563_545f, 0x0021_974a_6615_c81a), + P64::new(0xedb4_7c0a_e62d_ee9d, 0x0021_3767_697c_f36a), + P64::new(0x0a38_2438_6673_a573, 0x0021_1d9f_7fad_35f1), + P64::new(0xa4a7_7d19_e575_a0eb, 0x0020_fb7d_9dd3_6c18), + P64::new(0xa2be_e045_e066_c279, 0x0020_e212_3d66_1e0e), + P64::new(0xc236_18de_8ab4_3d05, 0x0020_d135_b66a_e990), + P64::new(0x266b_5152_16cb_9f2f, 0x0020_c8cd_ed4d_7a8e), + P64::new(0xe279_edd9_e9c2_e85b, 0x0020_b80b_3f43_ddbf), + P64::new(0xd0c5_91c2_21dc_9c53, 0x0020_96b9_180f_46a6), + P64::new(0x06da_8ee9_c9ee_7c21, 0x0020_7de7_e28d_e5da), + P64::new(0x9dfe_bcaf_4c27_e8c3, 0x0020_54de_c8cf_1fb3), + P64::new(0x49ae_ff9f_19dd_6de5, 0x0020_4cb6_30b3_aab5), + P64::new(0x8697_6a57_a296_e9c7, 0x0020_2428_adc3_7beb), + P64::new(0xa3b9_abf4_872b_84cd, 0x001f_ec0c_7834_def4), + P64::new(0x34fc_a648_3895_e6ef, 0x001f_c46f_ae98_a1d0), + P64::new(0x34b5_a333_988f_873d, 0x001f_acda_430f_f619), + P64::new(0xd9dd_4f19_b5f1_7be1, 0x001f_7e17_dd8e_15e5), + P64::new(0xb935_b507_fd0c_e78b, 0x001f_765a_3556_a4ee), + P64::new(0xb450_f554_0660_e797, 0x001f_66ea_49d8_02f1), + P64::new(0x63ff_8283_1ffc_1419, 0x001f_5f38_00fa_f9c0), + P64::new(0x8992_f718_c22a_32fb, 0x001f_38f4_e6c0_f1f9), + P64::new(0x5f32_53ad_0d37_e7bf, 0x001f_0b85_4675_2578), + P64::new(0x007c_0ffe_0fc0_07c1, 0x001f_03ff_83f0_01f0), + P64::new(0x4d8e_badc_0c06_40b1, 0x001e_c853_b0a3_883c), + P64::new(0xe272_9af8_3103_7bdb, 0x001e_c0ee_5737_23eb), + P64::new(0xb8f6_4bf3_0fee_bfe9, 0x001e_aad3_8e6f_6894), + P64::new(0xda93_124b_544c_0bf5, 0x001e_9c28_a765_fe53), + P64::new(0x9cf7_ff0b_593c_539f, 0x001e_94d8_758c_2003), + P64::new(0xd6bd_8861_fa0e_07d9, 0x001e_707b_a8f6_5e68), + P64::new(0x5cfe_75c0_bd8a_b891, 0x001e_53a2_a68f_574e), + P64::new(0x43e8_0875_7c2e_862b, 0x001e_1380_a56b_438d), + P64::new(0x90ca_a96d_595c_9d93, 0x001d_bf9f_513a_3802), + P64::new(0x8fd5_5062_5d07_135f, 0x001d_b1d1_d58b_c600), + P64::new(0x76b0_10a8_6e20_9f2d, 0x001d_9d35_8f53_de38), + P64::new(0xecc0_4264_4776_9b25, 0x001d_81e6_df61_65c7), + P64::new(0xe381_339c_aabe_3295, 0x001d_4bdf_7fd4_0e30), + P64::new(0xd1b1_90a2_d0c7_673f, 0x001d_452c_7a1c_958d), + P64::new(0xc3bc_e3cf_26b0_e7eb, 0x001d_37cf_9b90_2659), + P64::new(0x5f87_e76f_56c6_1ce3, 0x001d_1d3a_5791_e97b), + P64::new(0xc06c_6857_a124_b353, 0x001c_e89f_e6b4_7416), + P64::new(0x38c0_40fc_ba63_0f75, 0x001c_e219_f323_5071), + P64::new(0xd078_bc4f_bd53_3b21, 0x001c_d516_dcf9_2139), + P64::new(0xde8e_15c5_dd35_4f59, 0x001c_bb33_bd1c_2b8b), + P64::new(0xca61_d53d_7414_260f, 0x001c_a7e7_d254_6688), + P64::new(0xb56b_f5ba_8eae_635d, 0x001c_94b5_c1b3_dbd3), + P64::new(0x44a7_2cb0_fb6e_3949, 0x001c_87f7_f9c2_41c1), + P64::new(0x8798_39a7_14f4_5bcd, 0x001c_6202_706c_35a9), + P64::new(0x02a8_994f_de53_14b7, 0x001c_5bb8_a943_7632), + P64::new(0xb971_920c_f2b9_0135, 0x001c_1743_43b4_111e), + P64::new(0x8a8f_d0b7_df9a_6e8b, 0x001c_04d0_d3e4_6b42), + P64::new(0xb31f_9a84_c1c6_eaad, 0x001b_feb0_0fbf_4308), + P64::new(0x9229_3b02_823c_6d83, 0x001b_ec5d_ce0b_202d), + P64::new(0xeee7_7ff2_0fe5_ddcf, 0x001b_e034_4462_0037), + P64::new(0x0e1e_a0f6_c496_c11d, 0x001b_ce09_c66f_6fc3), + P64::new(0xfdf2_d3d6_f88c_cb6b, 0x001b_a402_28d0_2b30), + P64::new(0xfa9d_74a3_4577_38f9, 0x001b_9225_b1cf_8919), + P64::new(0xefc3_ca3d_b71a_5785, 0x001b_864a_2ff3_f53f), + P64::new(0x8e20_7171_8d0d_6daf, 0x001b_8060_4150_e49b), + P64::new(0xbc0f_dbfe_b6cf_abfd, 0x001b_6eb1_aaea_acf3), + P64::new(0x1eea_b613_e5e5_aee9, 0x001b_62f4_8da3_c8cc), + P64::new(0x2d23_88e9_0e9e_929f, 0x001b_516b_abe9_6092), + P64::new(0x81db_afba_588d_db43, 0x001b_2e9c_ef1e_0c87), + P64::new(0x52ee_bc51_c479_9791, 0x001b_1d56_bedc_849b), + P64::new(0x1c6b_c469_3b45_a047, 0x001b_0c26_7546_aec0), + P64::new(0x06ee_e097_4498_874d, 0x001a_e45f_6202_4fa0), + P64::new(0xd85b_7377_a995_3cb9, 0x001a_d917_631b_5f54), + P64::new(0x4b6d_f412_d4ca_f56f, 0x001a_c83d_18cb_608f), + P64::new(0x6b8a_fbbb_4a05_3493, 0x001a_a6c7_ad8c_063f), + P64::new(0xcc52_99c9_6ac7_720b, 0x001a_90a7_b122_8e2a), + P64::new(0xadce_84b5_c710_aa99, 0x001a_8027_c03b_a059), + P64::new(0x9d67_3f5a_a380_4225, 0x001a_7533_289d_eb89), + P64::new(0xe654_1268_efbc_e7f7, 0x001a_2ed7_ce16_b49f), + P64::new(0xfcf4_1e76_cf5b_e669, 0x0019_fefc_0a27_9a73), + P64::new(0x5c3e_b5dc_31c3_83cb, 0x0019_e4b0_cd87_3b5f), + P64::new(0x3018_32d1_1d8a_d6c3, 0x0019_cfcd_fd60_e514), + P64::new(0x2e9c_0942_f1ce_450f, 0x0019_c569_32d6_6c85), + P64::new(0x97f3_f2be_37a3_9a5d, 0x0019_b5e1_ab6f_c7c2), + P64::new(0xe8b7_d8a9_6541_87c7, 0x0019_b0b8_a62f_2a73), + P64::new(0xb5d0_24d7_da5b_1b55, 0x0019_a149_fc98_942c), + P64::new(0xb8ba_9d6e_7ae3_501b, 0x0019_6951_7ec2_5b85), + P64::new(0xf508_65f7_1b90_f1df, 0x0019_4b30_8336_0ba8), + P64::new(0x739c_1682_847d_f9e1, 0x0019_4631_f4be_bdc1), + P64::new(0xc470_a4d8_42b9_0ed1, 0x0019_1e84_1272_68fd), + P64::new(0x1fb1_be11_698c_c409, 0x0019_0adb_b543_984f), + P64::new(0xd8d5_512a_7cd3_5d15, 0x0019_0113_0bd1_8200), + P64::new(0xa549_6821_723e_07f9, 0x0018_e3e6_b889_ac94), + P64::new(0xbcc8_c6d7_abaa_8167, 0x0018_c233_420e_1ec1), + P64::new(0x52c3_96c9_5eb6_19a1, 0x0018_aa58_72d9_2bd6), + P64::new(0x6eb7_e380_878e_c74b, 0x0018_a598_9945_ccf9), + P64::new(0x3d55_13b5_0453_7157, 0x0018_9c1e_60b5_7f60), + P64::new(0x3143_91f8_862e_948f, 0x0018_893f_bc86_90b9), + P64::new(0xdc0b_17cf_cd81_f5dd, 0x0018_7b2b_b3e1_041c), + P64::new(0x2f6b_ea3e_c890_44b3, 0x0018_6d27_c9cd_cfb8), + P64::new(0xce13_a058_69f1_b57f, 0x0018_63d8_bf4f_2c1c), + P64::new(0x7593_474e_8ace_3581, 0x0018_5f33_e2ad_7593), + P64::new(0x07fc_3292_95a0_5e4d, 0x0018_55ef_7597_3e13), + P64::new(0xb053_77cb_a490_8d23, 0x0018_4816_0153_f134), + P64::new(0xe7b2_131a_628a_a39b, 0x0018_35b7_2e6f_0656), + P64::new(0x9031_dbed_7de0_1527, 0x0018_2c92_2d83_eb39), + P64::new(0x7684_4b1c_670a_a9a9, 0x0018_2802_43c0_365a), + P64::new(0x6a03_f453_3b08_915f, 0x0018_1a5c_d589_8e73), + P64::new(0x1dbc_a579_db0a_3999, 0x0018_03c0_9617_73aa), + P64::new(0x002f_fe80_0bff_a003, 0x0017_ff40_05ff_d001), + P64::new(0x478a_b1a3_e936_139d, 0x0017_e8d6_7043_3edb), + P64::new(0x66e7_22bc_4c5c_c095, 0x0017_d706_6cf4_bb5d), + P64::new(0x7a8f_63c7_1727_8541, 0x0017_ce28_5b80_6b1f), + P64::new(0xdf6e_ee24_d292_bc2f, 0x0017_af52_cdf2_7e02), + P64::new(0x9fc2_0d17_237d_d569, 0x0017_997d_47d0_1039), + P64::new(0xcdf9_9323_56bd_a2ed, 0x0017_7f7e_c2c6_d0ba), + P64::new(0x97b5_e332_e80f_68d7, 0x0017_7b2f_3cd0_0756), + P64::new(0x46ee_e26f_d875_e2e5, 0x0017_6e4a_22f6_92a0), + P64::new(0x3548_a8e6_5157_a611, 0x0017_65b9_4271_e11b), + P64::new(0xc288_d03b_e9b7_1e3b, 0x0017_6173_2b04_4ae4), + P64::new(0x8151_186d_b389_37ab, 0x0017_3f7a_5300_a2bc), + P64::new(0x7800_b910_895a_45f1, 0x0017_2211_2b48_be1f), + P64::new(0xaee0_b024_182e_ec3d, 0x0017_19b7_a16e_b843), + P64::new(0x9632_3eda_173b_5713, 0x0017_0d3c_99cc_5052), + P64::new(0x0ed0_dbd0_3ae7_7c8b, 0x0016_fcad_7aed_3bb6), + P64::new(0xf738_00b7_828d_c119, 0x0016_f051_b823_1ffd), + P64::new(0x1b61_715e_c22b_7ca5, 0x0016_e81b_eae2_0643), + P64::new(0xa853_3a99_1ead_64bf, 0x0016_c372_1584_c1d8), + P64::new(0x7f6c_7290_e46c_2e77, 0x0016_b34c_2ba0_9663), + P64::new(0x6325_e8d9_07b0_1db1, 0x0016_9f3c_e292_ddcd), + P64::new(0x2890_9f70_152a_1067, 0x0016_9344_b222_0a0d), + P64::new(0xea70_77af_0997_a0f5, 0x0016_8759_2593_c1b1), + P64::new(0x7e60_5cad_10c3_2e6d, 0x0016_7787_f141_8ec9), + P64::new(0x471b_3357_0635_b38f, 0x0016_63e1_9039_5ff2), + P64::new(0xab55_9fa9_97a6_1bb3, 0x0016_4c7a_4b6e_b5b3), + P64::new(0xad4b_dae5_62bd_dab9, 0x0016_316a_0611_82fd), + P64::new(0x055e_1b2f_2ed6_2f45, 0x0016_29ba_9145_84e4), + P64::new(0x03cd_328b_1a2d_ca9b, 0x0016_1e3d_57de_21b2), + P64::new(0xd28f_4e08_7332_18a9, 0x0016_12cc_01b9_77f0), + P64::new(0xb680_0b07_7f18_6293, 0x0016_0efe_30c5_25ff), + P64::new(0x6fbd_138c_3fd9_c207, 0x0015_da45_249e_c5de), + P64::new(0xb117_ccd1_2ae8_8a89, 0x0015_d68a_b4ac_ff92), + P64::new(0x2f1a_1a04_4046_bceb, 0x0015_c3f9_89d1_eb15), + P64::new(0x548a_ba0b_0605_41e3, 0x0015_b535_ad11_b8f0), + P64::new(0xcf4e_808c_ea11_1b2f, 0x0015_addb_3f42_4ec1), + P64::new(0xdbec_1b4f_a855_a475, 0x0015_9445_cb91_be6b), + P64::new(0xe3f7_94eb_600d_7821, 0x0015_8d01_9977_1e63), + P64::new(0x34fa_e0d9_a11f_7c59, 0x0015_7e87_d9b6_9e04), + P64::new(0xf006_b0cc_bbac_085d, 0x0015_68f5_8bc0_1ac3), + P64::new(0x3f45_076d_c311_4733, 0x0015_5e3c_993f_da9b), + P64::new(0xeef4_9bfa_58a1_a1b7, 0x0015_48ea_cc5e_1e6e), + P64::new(0x12c4_218b_ea69_1fa3, 0x0015_41d8_f91b_a6a7), + P64::new(0xbc75_04e3_bd5e_64f1, 0x0015_3747_060c_c340), + P64::new(0x4ee2_1c29_2bb9_2fad, 0x0015_1456_9f93_f7c4), + P64::new(0x3433_8b73_27a4_bacf, 0x0015_0309_705d_3d79), + P64::new(0x3fe5_c083_3d6f_ccd1, 0x0014_ff97_020c_f5bf), + P64::new(0xb1e7_0743_5352_03c1, 0x0014_e42c_114c_f47e), + P64::new(0xefbb_5dcd_fb4e_43d3, 0x0014_b835_bdcb_6447), + P64::new(0xca68_467c_a539_4f9f, 0x0014_b182_b53a_9ab7), + P64::new(0x8c51_c081_408b_97a1, 0x0014_ae2a_d094_a3d3), + P64::new(0x3275_a899_dfa5_dd65, 0x0014_9a32_0ea5_9f96), + P64::new(0x9e67_4cb6_2e1b_78bb, 0x0014_9044_1de1_a2fb), + P64::new(0xa37f_f5bb_2a99_8d47, 0x0014_89aa_cce5_7200), + P64::new(0x792a_999d_b131_a22b, 0x0014_75f8_2ad6_ff99), + P64::new(0x1b48_841b_c30d_29b9, 0x0014_6c2c_fe53_204f), + P64::new(0xf067_21d2_011d_3471, 0x0014_5f2c_a490_d4a1), + P64::new(0x93fd_2386_dff8_5ebd, 0x0014_58b2_aae0_ec87), + P64::new(0x4ce7_2f54_c07e_d9b5, 0x0014_4bcb_0a3a_3150), + P64::new(0xd6d0_fd3e_71dd_827b, 0x0014_28a1_e654_41d4), + P64::new(0x8564_05fb_1eed_819d, 0x0014_2575_a6c2_10d7), + P64::new(0x8ea8_aceb_7c44_3989, 0x0014_1f20_25ba_5c46), + P64::new(0x34a1_3026_f62e_5873, 0x0014_1bf6_e354_20fd), + P64::new(0x1eea_0208_ec0a_f4f7, 0x0014_0914_1d1d_313a), + P64::new(0x6367_9853_cea5_98cb, 0x0013_dd8b_c19c_3513), + P64::new(0xc30b_3ebd_61f2_d0ed, 0x0013_da76_f714_dc8f), + P64::new(0x7eb9_037b_c7f4_3bc3, 0x0013_d13e_50f8_f49e), + P64::new(0xa583_e6f6_ce01_6411, 0x0013_c80e_37ca_3819), + P64::new(0xf193_8d89_5f1a_74c7, 0x0013_bee6_9fa9_9ccf), + P64::new(0x80cf_1491_c1e8_1e33, 0x0013_b8d0_ede5_5835), + P64::new(0x3c0f_1288_6ba8_f301, 0x0013_afb7_680b_b054), + P64::new(0x0e4b_786e_0dfc_c5ab, 0x0013_acb0_c384_1c96), + P64::new(0x6726_84c9_3f2d_41ef, 0x0013_9a9c_5f43_4fde), + P64::new(0xe007_57ba_db35_c51b, 0x0013_949c_f33a_0d9d), + P64::new(0xd6d8_4afe_6647_2edf, 0x0013_82b4_a00c_31b0), + P64::new(0xfbbc_0eed_cbbf_b6e1, 0x0013_7fbb_c0ee_dcbb), + P64::new(0x250f_43aa_08a8_4983, 0x0013_70ec_f047_b069), + P64::new(0x0440_0e92_7b1a_caa5, 0x0013_6df9_790e_3155), + P64::new(0x5657_2be3_4b9d_3215, 0x0013_567d_d8de_fd5b), + P64::new(0x8796_4ef7_781c_62bf, 0x0013_5392_61fd_bc34), + P64::new(0x29ed_8405_1c06_e9af, 0x0013_3c56_4292_d28a), + P64::new(0xb00a_cd11_ed3f_87fd, 0x0013_33ae_178d_6388), + P64::new(0x0630_7881_7441_52d9, 0x0013_170a_d00d_1fd7), + P64::new(0x7a78_6459_f5c1_ccc9, 0x0013_005f_01db_0947), + P64::new(0x1308_125d_7456_3281, 0x0012_f51d_4034_2210), + P64::new(0x3953_10a4_80b3_e34d, 0x0012_ef81_5e4e_d950), + P64::new(0x3598_5baa_8b20_2837, 0x0012_ecb4_abcc_d827), + P64::new(0x9630_4a6e_052b_3223, 0x0012_e71d_c1d3_d820), + P64::new(0xbd82_65fc_9af8_fd45, 0x0012_e453_89a1_6495), + P64::new(0x1b6d_0b38_3ec5_8e0b, 0x0012_c5d9_2264_76cc), + P64::new(0xc21a_7c3b_68b2_8503, 0x0012_badc_3911_56fd), + P64::new(0x236f_a180_fbfd_6007, 0x0012_aa78_e412_f522), + P64::new(0xc42a_ccd4_40ed_9595, 0x0012_a251_f5f4_7fd1), + P64::new(0x7acf_7128_236b_a3f7, 0x0012_94cb_85c5_3534), + P64::new(0xf909_367a_987b_9c79, 0x0012_9219_63be_b65e), + P64::new(0xb64e_fb25_2bfb_a705, 0x0012_8cb7_77c6_9ca8), + P64::new(0x980d_4f5a_7e4c_d25b, 0x0012_84aa_6cf0_7294), + P64::new(0xe1ec_c4ef_27b0_c37d, 0x0012_81fc_f6ac_7f87), + P64::new(0x9111_aebb_81d7_2653, 0x0012_79f9_3736_7db9), + P64::new(0x8951_f985_cb2c_67ed, 0x0012_6cad_0488_be94), + P64::new(0xc439_d4fc_54e0_b5d7, 0x0012_6a06_7946_46a2), + P64::new(0xe857_bf31_896d_533b, 0x0012_5a2f_2bcd_3e95), + P64::new(0xb614_bb4c_b502_3755, 0x0012_4d10_8389_e6b1), + P64::new(0x938a_89e5_473b_f1ff, 0x0012_4a73_0837_71ac), + P64::new(0xeac4_81ac_a34d_e039, 0x0012_3d6a_cda0_620a), + P64::new(0x14b9_61ba_df48_09a7, 0x0012_2b4b_2917_eafd), + P64::new(0x7678_4fec_ba35_2435, 0x0012_2391_bfce_1e2f), + P64::new(0xefa6_89bb_58ae_f5e1, 0x0012_1e6f_1ea5_79f2), + P64::new(0xb2b2_c4db_9c3a_8197, 0x0012_16c0_9e47_1568), + P64::new(0x2503_bc99_2279_f8cf, 0x0012_0c8c_b9d9_3909), + P64::new(0xd2ab_9aec_5ca1_541d, 0x0012_04ed_58e6_4ef9), + P64::new(0x3e78_ba14_60f9_9af3, 0x0011_fd54_6578_f00c), + P64::new(0x0a01_4265_72cf_cb63, 0x0011_e931_0b8b_4c9c), + P64::new(0xbea8_5796_8f3c_bd67, 0x0011_da34_05db_9911), + P64::new(0x78db_213e_efe6_59e9, 0x0011_d7b6_f4eb_055d), + P64::new(0x963e_8541_a74d_35f5, 0x0011_d2be_e748_c145), + P64::new(0x9e22_d152_776f_2e43, 0x0011_c170_6ddc_e7a7), + P64::new(0x05d1_0d39_d1e1_f291, 0x0011_ba0f_ed2a_4f14), + P64::new(0x3744_68dc_cace_d1dd, 0x0011_b528_538e_d64a), + P64::new(0x8d14_5c7d_110c_5ad5, 0x0011_ab61_4042_42ac), + P64::new(0x3251_a39f_5acb_5737, 0x0011_9f37_8ce8_1d2f), + P64::new(0xa66e_5017_1443_506f, 0x0011_9588_9ece_79da), + P64::new(0x124f_69ad_91dd_4cbd, 0x0011_8e4c_6538_7077), + P64::new(0xec24_f8f2_a61a_2793, 0x0011_8716_1d70_e725), + P64::new(0xb472_148e_656b_7a51, 0x0011_6cd6_d1c8_5239), + P64::new(0x0adf_9570_e114_2f07, 0x0011_65bb_e7ce_86b1), + P64::new(0x89bf_33b0_6511_9789, 0x0011_635e_e344_ce36), + P64::new(0x8f01_4980_3cb2_91eb, 0x0011_5797_67b6_d679), + P64::new(0x8334_b63a_fd19_0a31, 0x0011_4734_711e_2b54), + P64::new(0x9209_08d5_0d6a_ba7d, 0x0011_428b_9014_7f05), + P64::new(0x57d8_b018_c5a3_3d53, 0x0011_3b92_f302_1636), + P64::new(0xea17_7309_2dc2_7ee5, 0x0011_26ca_bc88_6884), + P64::new(0xcae5_f38b_7bf2_e00f, 0x0011_247e_b1b8_5976), + P64::new(0x2bd0_2df3_4f69_5349, 0x0011_190b_b01e_fd65), + P64::new(0xddfe_cd5b_e62e_2eb7, 0x0011_091d_e0fd_679c), + P64::new(0xdbf8_49eb_ec96_c4a3, 0x0011_0496_3c7e_4e0b), + P64::new(0xda31_d4d0_1873_57c5, 0x0011_0253_5164_20b0), + P64::new(0xe34e_21cc_2d54_18a7, 0x0010_f70d_b7c4_1797), + P64::new(0x68ca_5137_a9e5_74ad, 0x0010_e75e_e2bf_9ecd), + P64::new(0x3eaa_0d0f_804b_fd19, 0x0010_e2e9_1c6e_0676), + P64::new(0x554f_b753_cc20_e9d1, 0x0010_da04_9b9d_428d), + P64::new(0x797a_fcca_1300_756b, 0x0010_c624_8fe3_b1a2), + P64::new(0x8b8d_950b_52ee_ea77, 0x0010_c1c0_3ed6_90eb), + P64::new(0xfb6c_d166_acab_c185, 0x0010_bb2e_1379_e3a2), + P64::new(0x4eb6_c5ed_9437_a7af, 0x0010_b8fe_7f61_228e), + P64::new(0xd1ed_dbd9_1b79_0cdb, 0x0010_b4a1_0d60_a4f7), + P64::new(0x93d7_14ea_4d89_48e9, 0x0010_ae19_2681_ec0f), + P64::new(0x3ca1_3ed8_1451_88d3, 0x0010_abec_fbe5_b0ae), + P64::new(0x8290_8601_6da8_9c57, 0x0010_9eef_d568_b96d), + P64::new(0xd7da_1f43_2124_a543, 0x0010_9a9f_f178_b40c), + P64::new(0x7ead_5581_632f_b07f, 0x0010_8531_e22f_9ff9), + P64::new(0x3544_3837_f63e_c3bd, 0x0010_6dde_c1af_4417), + P64::new(0x89e2_b200_e551_9461, 0x0010_6141_74a4_911d), + P64::new(0xe9ae_44f0_b728_9c0b, 0x0010_5f29_1f04_48e7), + P64::new(0x9438_7a27_7b9f_a817, 0x0010_5afa_0ef3_2891), + P64::new(0xc84f_1a58_abfc_2c25, 0x0010_54b7_77bd_2530), + P64::new(0x7110_1d8e_3c83_377b, 0x0010_4e79_a97f_b69e), + P64::new(0xc024_abe5_c50b_a69d, 0x0010_4c66_1eaf_d845), + P64::new(0x15de_4eb3_65a6_5d73, 0x0010_462e_a939_c933), + P64::new(0x09ed_28a7_6bcc_a931, 0x0010_2f8b_aa44_2836), + P64::new(0x816b_ffbf_4a00_205b, 0x0010_2d7f_f7e9_4004), + P64::new(0x1f5c_7154_3d55_8069, 0x0010_275f_f9f1_3c02), + P64::new(0xf25c_64d0_ec53_b859, 0x0010_1721_3fcb_b4d3), + P64::new(0x96c0_2c2e_f1e0_ff0f, 0x0010_1112_2345_79d1), + P64::new(0x19a8_0481_6870_a333, 0x0010_0501_907d_271c), + P64::new(0x6de4_9add_0971_c555, 0x0010_0300_901b_0510), + P64::new(0x5280_87e6_84c7_1aab, 0x000f_fd00_8fe5_050f), + P64::new(0xa941_52c2_69bc_deef, 0x000f_f10e_02dd_5084), + P64::new(0x0379_450a_3c2b_6bdf, 0x000f_e13b_9c80_c67f), + P64::new(0xd2cd_38ba_fe53_73e1, 0x000f_df43_84be_37ad), + P64::new(0xc29d_f2be_a71d_8bad, 0x000f_db54_cbe8_766e), + P64::new(0xc158_6277_5f30_2e83, 0x000f_d572_5ca6_ff32), + P64::new(0x1016_af2f_e55e_de09, 0x000f_c7c8_4684_c6fb), + P64::new(0x3d26_dbd9_d191_0715, 0x000f_c3e5_265d_baa8), + P64::new(0x621d_ab2d_faf3_dfbf, 0x000f_c1f4_4e0c_ae12), + P64::new(0xb6f1_d7ac_2873_38b1, 0x000f_b092_1c50_a7af), + P64::new(0x8d9e_9f0c_3f9e_7fd9, 0x000f_999f_d70c_bc6b), + P64::new(0x60a9_3f87_62e9_14bb, 0x000f_9023_fd53_39d0), + P64::new(0xb143_71f2_47c1_59c9, 0x000f_8a78_ce67_1475), + P64::new(0x6dd3_b484_471d_4eb3, 0x000f_8895_fee8_6574), + P64::new(0xcd17_2f47_01c1_684d, 0x000f_7f2e_cb08_4b10), + P64::new(0x0372_e686_ed8b_b537, 0x000f_7d4e_b7d1_0c29), + P64::new(0xbc07_f7ca_65c5_b071, 0x000f_73f5_2277_a3c3), + P64::new(0xab2b_6170_c3f7_8d9b, 0x000f_7217_c598_961c), + P64::new(0xf3d7_4f46_1fe6_f5b5, 0x000f_68cb_b144_8f42), + P64::new(0xdbc1_3f4b_31f3_230b, 0x000f_633d_0276_e4c5), + P64::new(0xd142_0716_e3f1_572d, 0x000f_6163_ac20_ec79), + P64::new(0xd5be_2fd4_d805_464f, 0x000f_582b_a2bc_16c6), + P64::new(0xc68b_97c1_3694_3851, 0x000f_5654_f432_90a0), + P64::new(0x9e27_918a_f7cf_b473, 0x000f_4d2a_2381_0bc6), + P64::new(0x5ec8_ab6c_36ac_7f41, 0x000f_47af_4d6a_2f27), + P64::new(0x9640_7633_1dd9_0979, 0x000f_4066_f2b6_e652), + P64::new(0x3019_8eff_77b0_02d7, 0x000f_2555_048e_3a92), + P64::new(0x3af7_cb95_83ec_e011, 0x000f_1c64_588a_5bf6), + P64::new(0x34ce_06f6_43d9_883b, 0x000f_1a9b_e09c_b411), + P64::new(0x79f7_67e5_2870_8c55, 0x000f_11b7_d525_9d39), + P64::new(0x1853_32d2_ef23_13cd, 0x000f_0aa2_84e7_f802), + P64::new(0x43b6_11b8_4c83_32a3, 0x000f_0556_e5e3_b7f2), + P64::new(0xc2e2_15e4_f43b_b63d, 0x000e_fc8b_cbc8_08e5), + P64::new(0xf94b_9dd2_2ce4_4e97, 0x000e_ecd1_a690_efbb), + P64::new(0xd895_834a_1db1_66a5, 0x000e_e79a_ed6d_65f2), + P64::new(0x347d_2f16_d19b_8d09, 0x000e_dd38_6114_d83a), + P64::new(0x1b54_d4dc_45b7_d98d, 0x000e_d2e4_4366_e5e2), + P64::new(0x117a_c30d_9a04_4877, 0x000e_d12c_f8e1_7f64), + P64::new(0x0e10_b78a_67a5_26e9, 0x000e_c1cd_284b_2b2d), + P64::new(0x92da_68a8_1868_8a9f, 0x000e_bcb4_4cad_da1e), + P64::new(0xcf2b_6c87_f741_f84b, 0x000e_b950_5943_771d), + P64::new(0xd264_f9bd_41e1_8ed9, 0x000e_b43d_57ef_eadc), + P64::new(0x733c_beaa_9716_6d8f, 0x000e_af2d_d4c0_0b03), + P64::new(0xc9f4_75b0_21d2_2e81, 0x000e_a014_1c1b_a6a6), + P64::new(0x731f_76f2_ec4c_852b, 0x000e_9e68_805f_05a7), + P64::new(0xdaf6_f0c9_78f6_9945, 0x000e_9614_2b87_e431), + P64::new(0x749c_8ad2_0c61_ec93, 0x000e_8a7a_cd81_1b8c), + P64::new(0x0930_7ff8_bd3c_1261, 0x000e_8587_db3e_001d), + P64::new(0x334a_69fb_5a48_6e2d, 0x000e_823d_186d_44dc), + P64::new(0x1f36_c7bf_3157_8617, 0x000e_8098_463e_e194), + P64::new(0x31eb_bcc2_79ea_6103, 0x000e_7d4f_bfb3_ee1d), + P64::new(0x42e2_aad1_19f4_66eb, 0x000e_69bb_a698_1ffa), + P64::new(0x106e_c05a_0ab1_450d, 0x000e_681c_5cf7_d707), + P64::new(0xb1b3_8db9_2a99_e731, 0x000e_5e68_4930_e334), + P64::new(0x784a_e377_e670_71e7, 0x000e_5993_247d_c92d), + P64::new(0x3e9e_1471_ba66_71d7, 0x000e_4cbf_ee20_1016), + P64::new(0x82c2_9b59_d4d7_3d0f, 0x000e_465e_e7da_f979), + P64::new(0xc23d_d071_28b5_525d, 0x000e_4199_de07_af5c), + P64::new(0x4d4e_5ce0_e924_5133, 0x000e_3cd8_031d_4f40), + P64::new(0xc8fd_1057_c09f_8cc5, 0x000e_2ea5_6c15_7eb2), + P64::new(0xea15_16e9_4f39_4035, 0x000e_221e_5d4d_3c73), + P64::new(0xb5e3_319c_564e_e9df, 0x000e_208f_09a8_41c7), + P64::new(0x126a_69f9_0d82_2d8b, 0x000e_1d71_6a94_5161), + P64::new(0x501e_d634_8857_aa19, 0x000e_18c7_8ec8_fd4d), + P64::new(0xde34_4a32_4eee_1c83, 0x000e_173a_4a16_2079), + P64::new(0x1dd9_690c_b2c4_06d1, 0x000e_1294_881b_b494), + P64::new(0x08d6_c517_8d5e_4387, 0x000e_0df1_d5f2_4661), + P64::new(0x4cea_4050_a3e8_fdc1, 0x000e_063e_c7f5_0b1e), + P64::new(0xc114_a06a_cc83_f777, 0x000e_01a4_313d_c53d), + P64::new(0x20b0_60eb_c0ea_01db, 0x000d_f878_0f47_c350), + P64::new(0xfe50_045a_cb78_c99f, 0x000d_ef57_e8eb_9666), + P64::new(0x291a_6870_5b19_6e91, 0x000d_e1bd_f3f6_3d46), + P64::new(0xc104_2c72_4273_e2bb, 0x000d_e03c_b509_9809), + P64::new(0x2cee_680b_b165_b7c9, 0x000d_dbba_ecc8_4bc9), + P64::new(0xfd2f_f9f1_2e07_76d5, 0x000d_d8bb_5ca7_3db6), + P64::new(0x166a_5da6_3af2_cc6f, 0x000d_cb4d_529a_6e07), + P64::new(0xedd1_6a59_3040_8d27, 0x000d_c55d_a73d_ea60), + P64::new(0x2adf_30c2_6528_844f, 0x000d_b3ad_2585_011f), + P64::new(0x9a48_d657_2b5e_ec7b, 0x000d_b0be_cf63_6a79), + P64::new(0x6e8b_f287_7503_cb9d, 0x000d_af48_1ca6_fefb), + P64::new(0xea27_a191_a704_5389, 0x000d_ac5b_a756_5dae), + P64::new(0x6eb0_91f3_4dd4_5d3f, 0x000d_a7fb_4e41_9d19), + P64::new(0xdc8a_6cab_b293_7d41, 0x000d_a686_7a88_d327), + P64::new(0xbc2f_04f2_5492_2a05, 0x000d_9dd0_05f5_0b02), + P64::new(0x4143_1f4d_6eb3_8631, 0x000d_9aeb_01f7_63f7), + P64::new(0x7bd7_1743_5a08_291f, 0x000d_90d3_1dd5_804a), + P64::new(0x4232_df9c_91fc_1a55, 0x000d_7b64_5335_8f31), + P64::new(0xa465_1e1d_5382_eab7, 0x000d_744e_69d9_00e4), + P64::new(0x7cfb_5409_de4c_f3c5, 0x000d_7011_a317_260e), + P64::new(0xcdd6_36fb_068b_9929, 0x000d_67a0_126e_7c19), + P64::new(0xee8f_95e7_4046_2c97, 0x000d_5dd3_9e77_5bd7), + P64::new(0x490f_97b3_a758_b4a5, 0x000d_59a4_f299_0168), + P64::new(0x6414_3156_3c44_1287, 0x000d_52b2_4cb6_269d), + P64::new(0xb743_dad3_ec45_916b, 0x000d_4a65_71da_4f04), + P64::new(0x7b18_8be8_f55c_878d, 0x000d_4904_4eac_6581), + P64::new(0xd805_648b_2ca5_4ef9, 0x000d_4642_e40d_1129), + P64::new(0x76db_e6ee_f601_23af, 0x000d_4222_e81f_e723), + P64::new(0x3711_525e_6a9e_8867, 0x000d_3ca6_e8c8_9f41), + P64::new(0x85c2_215c_b383_d8f5, 0x000d_388c_e29d_4edc), + P64::new(0xe58f_554c_8982_5857, 0x000d_31bc_7b7d_8013), + P64::new(0x8fbd_3b17_c01d_acd9, 0x000d_3060_71c1_3fd5), + P64::new(0x4c8c_39dc_7aed_ee65, 0x000d_2da9_3547_9b1a), + P64::new(0x653a_c6dd_a86c_d3b3, 0x000d_2430_aa04_3597), + P64::new(0x0d61_c679_1a9c_2c81, 0x000d_2025_bc6c_7db7), + P64::new(0xb627_a300_9035_4237, 0x000d_1c1d_4ad1_732b), + P64::new(0x83a8_9a53_9c52_7c23, 0x000d_196e_5f46_f8c8), + P64::new(0x28c8_c093_30e9_0d71, 0x000d_156a_0c92_93e8), + P64::new(0xee11_78d2_7b1f_029b, 0x000d_1413_d26e_0aee), + P64::new(0xcecc_740b_3786_0ab5, 0x000d_0d68_c6a4_128f), + P64::new(0x7973_6fde_910c_485f, 0x000d_0c14_2eaf_3837), + P64::new(0x6873_d51f_2487_234f, 0x000d_0179_2ab9_d70d), + P64::new(0x2a11_2180_614f_b973, 0x000c_f990_3177_75bc), + P64::new(0xcb04_cea9_8508_f4eb, 0x000c_f44f_8c38_790a), + P64::new(0xc2fc_d2c5_27e2_8d7d, 0x000c_e88d_96d1_0e45), + P64::new(0x9802_03ee_1039_3c69, 0x000c_e5f3_9b07_e906), + P64::new(0x3fa9_0a1d_7d75_681f, 0x000c_e20e_9814_8847), + P64::new(0xdbf3_bfef_ef21_7cc3, 0x000c_da4b_9c30_ccd7), + P64::new(0x66a1_7fd3_087b_41e5, 0x000c_d901_5ae3_2495), + P64::new(0x9621_95d4_96fb_bd3b, 0x000c_d524_244a_ca36), + P64::new(0xc705_a861_5544_3e49, 0x000c_d149_4009_9cf6), + P64::new(0x3f29_8ee0_be6f_ebff, 0x000c_cd70_ac08_9a07), + P64::new(0xaa99_b084_e62f_a613, 0x000c_bb9c_535c_4371), + P64::new(0x1f00_0cb7_d0b4_6fe1, 0x000c_b7d0_b46f_e0ff), + P64::new(0x9ed7_8586_37c9_b2cf, 0x000c_aefe_5d71_35f4), + P64::new(0x4d87_1aaf_27c1_06fb, 0x000c_ac7b_5f00_f0cd), + P64::new(0x2e6a_467c_dc75_a4f3, 0x000c_a778_5ced_dbea), + P64::new(0xe9d9_38fb_696d_de8d, 0x000c_a13a_2a86_e1db), + P64::new(0x40ec_71b0_b155_4485, 0x000c_9c40_0975_3007), + P64::new(0x3aae_12f8_61e5_f3e9, 0x000c_94d0_2e64_bfab), + P64::new(0xa975_6587_3959_f843, 0x000c_89b8_c9c8_75ef), + P64::new(0x0b5a_960c_09fb_ca8f, 0x000c_8744_7737_277e), + P64::new(0x463f_e3d2_6801_2c91, 0x000c_860a_aa25_14e3), + P64::new(0xe59a_6bd5_f5ee_1bdd, 0x000c_8397_c813_f1b9), + P64::new(0x6542_e84d_7775_ce45, 0x000c_74fa_805d_6d56), + P64::new(0x8b6e_ef58_fd9e_ffa9, 0x000c_6db8_a1f5_cdfe), + P64::new(0x5899_3dbb_9f98_075f, 0x000c_6a1a_dd9e_2398), + P64::new(0x2997_955a_810a_cf61, 0x000c_68e6_be82_6648), + P64::new(0x76e3_d2f5_077d_b451, 0x000c_5f4e_25fc_9df0), + P64::new(0xb37c_1d28_67e3_0907, 0x000c_5bb8_bf2a_d1cd), + P64::new(0x53ce_6e09_bd8d_8695, 0x000c_5825_6b31_6ced), + P64::new(0x39db_291e_a2a6_b0e3, 0x000c_4fd5_ad91_7b5b), + P64::new(0xddd2_65ab_9c58_847d, 0x000c_49ec_b3ea_4d7a), + P64::new(0x5bec_a856_2ddd_d0cb, 0x000c_41b0_0b7d_950a), + P64::new(0xb690_31c1_53dd_bed7, 0x000c_3f57_990b_87a1), + P64::new(0xd03c_2271_b42a_6fcd, 0x000c_2ddc_b312_50f8), + P64::new(0xcd6f_d19e_63e4_0ea3, 0x000c_2a63_b365_1432), + P64::new(0xf768_7aa8_e4fd_7bf1, 0x000c_26ec_ae1d_b72e), + P64::new(0x649d_fda1_12a2_72a7, 0x000c_2377_a18c_051e), + P64::new(0xecf7_866a_56d5_26df, 0x000c_1ede_9efc_ec29), + P64::new(0x72bb_f1cf_daeb_fead, 0x000c_1b6e_258d_13a0), + P64::new(0x55f6_a48d_f705_5719, 0x000c_1924_3f53_99bb), + P64::new(0x8006_0bff_cfa0_0183, 0x000c_17ff_9f40_0305), + P64::new(0x8a10_4f30_9919_b087, 0x000c_1128_6570_3b94), + P64::new(0x98fa_7db7_652f_6a15, 0x000c_0dbf_aea3_3225), + P64::new(0x5d7d_1b3d_f70f_7ac1, 0x000c_0b7a_f12d_dfb9), + P64::new(0x16ab_7b5e_04cc_1f6b, 0x000c_0a58_e464_462c), + P64::new(0x78a5_bfd2_e5ec_ecf9, 0x000c_06f4_0512_eef2), + P64::new(0x6506_392e_171d_869f, 0x000b_fa92_75a2_b247), + P64::new(0xc3fc_12e2_21ef_146d, 0x000b_f736_7402_cdf0), + P64::new(0xf8aa_1328_22c3_3657, 0x000b_f618_33f4_f921), + P64::new(0x8944_9657_4f53_6f43, 0x000b_f3dc_543a_74a1), + P64::new(0x8b25_46b0_8fb4_cbd5, 0x000b_e9d9_302a_7115), + P64::new(0x043b_bb56_1bd1_aa7f, 0x000b_e8bd_6e05_1e01), + P64::new(0x2412_c7cc_4ea7_a12b, 0x000b_e686_8804_d5a6), + P64::new(0x6f0b_d406_dd71_696f, 0x000b_dfe6_c435_9f0e), + P64::new(0xad47_5c69_88d5_4b71, 0x000b_decc_db0b_5c3a), + P64::new(0xd812_e5d4_8dbb_ba27, 0x000b_db80_58ee_429a), + P64::new(0x22aa_ca43_7ba0_4893, 0x000b_d94e_5c1b_371f), + P64::new(0xdba6_ff1f_ecd5_f09d, 0x000b_cb1d_293b_1af3), + P64::new(0x1301_6d33_9628_6773, 0x000b_c7db_8db0_c1a5), + P64::new(0xc746_4946_31bc_fa41, 0x000b_c49b_bdfd_2662), + P64::new(0xd148_8856_5bf6_a10d, 0x000b_c272_3240_f402), + P64::new(0xc002_ef88_5f0a_df05, 0x000b_be21_7c2b_7c13), + P64::new(0xe5a0_4da7_fee6_ade7, 0x000b_b8c1_0aab_27b2), + P64::new(0xc114_ce54_6859_3bc7, 0x000b_a7ad_528a_7e79), + P64::new(0x0bb6_747d_d7f5_77b7, 0x000b_9f36_11b4_8c5e), + P64::new(0x395c_e5a2_0f28_5839, 0x000b_9e28_06e5_e7c4), + P64::new(0x6eee_8be6_6e86_18ef, 0x000b_9aff_0c49_13fe), + P64::new(0x52ac_f642_97f1_241b, 0x000b_98e4_aedd_581c), + P64::new(0x361d_cc48_a364_093d, 0x000b_97d7_c94b_7dc2), + P64::new(0x342d_6f47_5d72_e629, 0x000b_95be_902d_9d9e), + P64::new(0x5e97_8bd4_6410_d413, 0x000b_94b2_3c87_2b90), + P64::new(0xcc34_33d7_5ba0_15ad, 0x000b_8f77_714d_15a1), + P64::new(0x1c83_b762_8458_d4fb, 0x000b_882d_0bef_f6a1), + P64::new(0xf9ca_4563_7e38_f809, 0x000b_850f_f985_2703), + P64::new(0xcbed_792f_faf6_b115, 0x000b_82fd_86db_8806), + P64::new(0x9abd_961d_8c0e_8c8d, 0x000b_7eda_dd32_f76c), + P64::new(0xe695_72fa_6593_40af, 0x000b_79b3_b4df_3b7b), + P64::new(0x9187_e748_3a64_36fd, 0x000b_769e_6d59_833f), + P64::new(0x1e9c_7269_93be_d9d9, 0x000b_6c63_6b51_41ff), + P64::new(0x2435_54db_9197_6365, 0x000b_6a59_ceae_8801), + P64::new(0x04d0_6ff9_94c0_088f, 0x000b_6955_461e_38f7), + P64::new(0x25b7_6abc_b748_89dd, 0x000b_6648_c2dc_6bc2), + P64::new(0x3a40_9642_893c_779b, 0x000b_5722_8226_0209), + P64::new(0x8f8f_620d_8bc0_c927, 0x000b_5520_72bd_e889), + P64::new(0x6f9f_196b_3369_855f, 0x000b_511e_7552_f9c4), + P64::new(0x92a5_22bb_0638_ed99, 0x000b_4c1f_f34a_5c0e), + P64::new(0x9627_0f1e_fdd7_004f, 0x000b_4922_f58d_4aa2), + P64::new(0xb484_4b38_0fda_a79d, 0x000b_4627_8c16_b967), + P64::new(0x1089_36aa_5f9c_1495, 0x000b_4230_1cd9_9b49), + P64::new(0x0b60_f606_f104_c9eb, 0x000b_3f38_5dd7_7e4e), + P64::new(0xc663_dfe8_263b_302f, 0x000b_394d_8ef8_f0f6), + P64::new(0xc91a_280b_9110_b15b, 0x000b_3756_0150_7c14), + P64::new(0x0904_2871_18d1_0969, 0x000b_3463_f76b_e376), + P64::new(0x160d_36a5_d31b_f553, 0x000b_3368_f6c4_a07c), + P64::new(0xe84f_5fda_3c67_ad21, 0x000b_3078_fc1c_25f0), + P64::new(0xbd85_701f_72d4_b6ed, 0x000b_2e84_854e_93e5), + P64::new(0x4c50_cf59_24de_e1c3, 0x000b_2b97_1aa9_09a4), + P64::new(0x2455_aaf1_633b_b6e5, 0x000b_2a9d_a39d_6bc8), + P64::new(0xd775_b39f_549b_8ac7, 0x000b_25c0_dc29_a0fc), + P64::new(0x87fc_dda7_a252_cb49, 0x000b_24c8_6984_49a7), + P64::new(0x53df_2e3b_d254_a739, 0x000b_1d0a_e579_aefe), + P64::new(0x8915_e696_23a5_f7ef, 0x000b_1a26_98ea_2f9e), + P64::new(0x1ef2_4c80_742d_d08b, 0x000b_108d_c418_6078), + P64::new(0xb4d8_7aaa_6fb1_e897, 0x000b_0ea4_63b0_0212), + P64::new(0x7885_73e8_b92d_bbfb, 0x000b_08ec_3700_7962), + P64::new(0x0252_7b13_7b08_78c1, 0x000b_0247_78cc_023c), + P64::new(0x1870_a7c8_dee9_f4f5, 0x000a_f515_df36_a88e), + P64::new(0x39b9_9e40_910a_224b, 0x000a_f246_35f6_561e), + P64::new(0x4582_1c0a_bd4d_f247, 0x000a_e8f1_b92b_aeaf), + P64::new(0x10fe_2b2f_50e0_2fb3, 0x000a_e715_eee1_1f8e), + P64::new(0x5762_b90c_043f_0345, 0x000a_dec0_b0a3_bb36), + P64::new(0x82a6_7b91_93b2_7bbd, 0x000a_db10_aa4c_956f), + P64::new(0xa6e9_14e2_8ec3_7693, 0x000a_d84e_4975_2245), + P64::new(0x835d_9a4f_acaf_445f, 0x000a_d678_2597_f0c2), + P64::new(0x48de_f817_5884_f82d, 0x000a_d3b8_1a0d_72fe), + P64::new(0xae90_0e2d_7c9a_6f7b, 0x000a_cd52_bece_d79e), + P64::new(0x1c08_431b_dd18_be89, 0x000a_ca97_5506_3254), + P64::new(0xb370_a66d_684f_d83f, 0x000a_c7dd_4caf_b12a), + P64::new(0xb4be_33e1_8f93_b279, 0x000a_c354_f80d_ca44), + P64::new(0x310c_5087_2a7d_d5e3, 0x000a_c26d_5c2b_8ad2), + P64::new(0x447a_b128_1276_697d, 0x000a_bde9_97da_bd3d), + P64::new(0xc2f1_2221_6b2a_6c21, 0x000a_b883_aa11_00a0), + P64::new(0xab99_c8b5_ae1c_3059, 0x000a_b4ed_637f_5a0b), + P64::new(0xb78e_17a2_227d_593b, 0x000a_b074_e9fe_bf52), + P64::new(0xabf9_7d03_f726_9c5d, 0x000a_af90_778c_2039), + P64::new(0x867a_efc9_fdbf_e7ff, 0x000a_ab1c_7684_f034), + P64::new(0xf7f7_ad18_2e47_d5b7, 0x000a_a78f_20eb_bb3e), + P64::new(0x50df_f95a_9847_721b, 0x000a_a23f_8daf_d4cc), + P64::new(0xe4cb_8a0e_83cb_6a35, 0x000a_9dd6_9cad_5934), + P64::new(0x8da7_2ecd_f924_7a1d, 0x000a_9350_04a0_7302), + P64::new(0xc5b0_4bfc_87f3_1d87, 0x000a_9270_690f_3d14), + P64::new(0xe2dc_f622_ea2b_00f3, 0x000a_90b1_a0aa_5d30), + P64::new(0xb9ce_9f2e_4972_f46b, 0x000a_8d35_c9d7_31e9), + P64::new(0x1ed7_85c9_11bf_59f9, 0x000a_8a9a_6a51_f16c), + P64::new(0x4ddb_8a4e_ed70_e085, 0x000a_88de_370f_596b), + P64::new(0x81e9_3b4d_f68c_24fd, 0x000a_8567_86ad_ae36), + P64::new(0xee0d_0812_afcd_8357, 0x000a_7da4_c77d_3161), + P64::new(0xf62e_3ba7_2268_a891, 0x000a_7959_f863_d4a1), + P64::new(0x3194_d367_c815_4147, 0x000a_76c8_5e80_c195), + P64::new(0xd096_ede8_e30c_20d5, 0x000a_7438_06dc_44c4), + P64::new(0xd686_24d2_7b87_a77f, 0x000a_735d_866d_fa0a), + P64::new(0xb728_fcdc_11c8_204d, 0x000a_70ce_db02_531e), + P64::new(0x9d6b_6038_077e_066f, 0x000a_6c8e_842c_770f), + P64::new(0xaa73_2d7a_4a36_0d93, 0x000a_6779_1215_dd74), + P64::new(0x36af_98a4_2397_2db5, 0x000a_66a0_a51d_363d), + P64::new(0xc31d_00da_1294_0f17, 0x000a_6268_9301_1861), + P64::new(0xed85_3521_0741_0b25, 0x000a_5fe2_2c55_c089), + P64::new(0x829c_85ee_6db8_567b, 0x000a_5d5c_ffb7_7275), + P64::new(0xef60_2589_52cc_6d89, 0x000a_5ad9_0c41_86e5), + P64::new(0xcf28_c2e0_da78_7741, 0x000a_5780_57e7_c2eb), + P64::new(0x5756_7d84_94af_28f7, 0x000a_54ff_3bb1_0e91), + P64::new(0x2c7c_9851_8f17_4031, 0x000a_50d5_683e_dc94), + P64::new(0xb28b_363a_3682_5ae7, 0x000a_4e57_854b_3df4), + P64::new(0xed1f_feb6_4f9a_e769, 0x000a_4d83_28c4_b800), + P64::new(0xcbbb_0115_e9b9_a31f, 0x000a_4b06_e01d_97b3), + P64::new(0x8d3c_5fec_b7f9_e4ed, 0x000a_488b_ca2c_4449), + P64::new(0x8162_7169_8195_cfc3, 0x000a_4611_e613_2ed5), + P64::new(0x9ac9_39d1_c2b1_d35d, 0x000a_41f4_0f39_e646), + P64::new(0xdd9f_b701_7b0e_c455, 0x000a_3eab_5c3e_44e9), + P64::new(0xc94c_ab1e_5727_6e3d, 0x000a_34dd_d505_61e0), + P64::new(0x8b88_06b1_17c7_9913, 0x000a_326d_60e9_4186), + P64::new(0xa9e6_3292_a326_9fd1, 0x000a_2985_a81c_e614), + P64::new(0x76da_5710_f1e9_89fb, 0x000a_28b7_2e26_f82e), + P64::new(0xdded_6688_d83a_918d, 0x000a_217a_a347_9693), + P64::new(0x4e44_6b6a_3054_28f9, 0x000a_1fe0_5c62_df4b), + P64::new(0x4dda_ca7a_3696_cfb1, 0x000a_1cad_538a_ebf9), + P64::new(0x7ead_c4eb_87f2_6ed3, 0x000a_18b0_5f49_0083), + P64::new(0x76c1_3a0f_f04c_00c9, 0x000a_0ccc_4c28_fc31), + P64::new(0xcbf8_0050_4d2a_2681, 0x000a_09a5_44d0_1ffe), + P64::new(0x0731_dada_6c4f_ec9b, 0x000a_0294_aa53_e9a2), + P64::new(0xbcb5_2a66_4e63_f627, 0x000a_0104_1a6a_aed5), + P64::new(0xf1f9_abda_071c_2aa9, 0x000a_003c_0168_0870), + P64::new(0xf262_ffa6_20ff_e20b, 0x0009_fc55_58a9_71c8), + P64::new(0x9377_4a3d_5719_9a99, 0x0009_f9ff_9c3c_03e5), + P64::new(0xfb35_41cd_467a_1903, 0x0009_f938_9b86_4ab9), + P64::new(0x6828_cab6_b4fe_8f51, 0x0009_f6e4_534b_dca8), + P64::new(0x12ac_03e3_d624_cc9d, 0x0009_f557_6872_35c2), + P64::new(0x6363_bd1e_9bb7_d7f7, 0x0009_ee63_3c03_91ab), + P64::new(0x334c_fd67_6a48_4d2f, 0x0009_eb4f_28e0_bb39), + P64::new(0xd511_acd8_6f14_3a53, 0x0009_e6b4_9e92_e4bb), + P64::new(0x73fc_2490_e006_2be5, 0x0009_dfd4_ccbd_0045), + P64::new(0x1078_0dda_36b7_8b55, 0x0009_d9c0_8285_36c1), + P64::new(0xabf6_0127_4064_e0ab, 0x0009_d77a_d449_f777), + P64::new(0x3ef3_e4ca_27e4_a2cd, 0x0009_d6b9_2b28_ee48), + P64::new(0x9216_a26e_690a_16f1, 0x0009_d231_a476_ed51), + P64::new(0xbae4_849e_6034_bda7, 0x0009_cfef_711b_f120), + P64::new(0xf943_a052_0e01_e9e1, 0x0009_cc2e_1448_b765), + P64::new(0x7c89_958f_48f6_658b, 0x0009_cb6e_26cb_c64d), + P64::new(0xe671_2875_0e05_45a5, 0x0009_c7b0_3b4a_9c67), + P64::new(0xc6c9_e1d4_1451_6ccf, 0x0009_c6f0_fd98_0ab1), + P64::new(0x8053_07f9_96e9_e81d, 0x0009_c4b3_f3a3_0c3f), + P64::new(0x3edd_d2cf_f46a_d5bf, 0x0009_c0fb_2943_6687), + P64::new(0x3558_2c1a_eb5a_ae85, 0x0009_bbca_025b_7aec), + P64::new(0x4973_c885_73ef_6eb1, 0x0009_ba4f_4421_e52c), + P64::new(0x3063_f627_c1e7_15d9, 0x0009_b178_3809_ff03), + P64::new(0x711a_d679_a8dc_c243, 0x0009_b0bc_5b4d_2eac), + P64::new(0x51c2_24a1_7a3d_b4b3, 0x0009_aae1_72fd_8b9c), + P64::new(0x6123_25ca_50dd_aed5, 0x0009_aa26_9546_07ed), + P64::new(0x9929_a7b6_b795_8b37, 0x0009_a681_e758_a022), + P64::new(0xa78d_222e_5a85_7bb9, 0x0009_a5c7_b284_942e), + P64::new(0x3ad0_ffe3_198d_139b, 0x0009_a226_4ecc_5558), + P64::new(0x08b4_659a_c547_ed17, 0x0009_9aeb_b39b_e56f), + P64::new(0x1752_e890_4aff_1003, 0x0009_997a_e1a9_faac), + P64::new(0x6074_5c37_ee4e_5925, 0x0009_98c2_a22b_6900), + P64::new(0x29e2_da1f_6557_ee51, 0x0009_9752_7603_f8a8), + P64::new(0x80d7_8c24_ac49_cb89, 0x0009_9473_685e_4d50), + P64::new(0xc56c_3b49_5c8d_1f79, 0x0009_8eba_7251_2a13), + P64::new(0xcf5b_df9f_5088_ac2f, 0x0009_8c96_d8de_e9e1), + P64::new(0x8a44_800e_4fae_4e7d, 0x0009_8a74_3453_554e), + P64::new(0xdd76_3842_77e5_78e7, 0x0009_89be_33c9_e6bd), + P64::new(0x20b1_562d_2703_facb, 0x0009_857c_692e_9a59), + P64::new(0xef56_caf9_6e9d_8e3b, 0x0009_7fd5_40c0_5c9e), + P64::new(0xf540_6141_6aed_e033, 0x0009_7d04_302e_d944), + P64::new(0xe0bc_78c2_1a26_e4ff, 0x0009_7b9c_4828_9935), + P64::new(0x0524_f927_31a1_79cd, 0x0009_7981_33ec_e717), + P64::new(0x5d3b_4ad7_deaf_ec8b, 0x0009_6f07_c683_689e), + P64::new(0x5088_28f7_44da_88ad, 0x0009_6e55_d639_3fc5), + P64::new(0x6e82_0140_3171_0bcf, 0x0009_6add_ad86_1696), + P64::new(0xadf3_b77a_2259_5dd1, 0x0009_6a2c_5a2c_f0cf), + P64::new(0x0d8f_0c03_f7ea_8a87, 0x0009_6818_fc82_5eba), + P64::new(0x2c49_e348_3c3a_05f3, 0x0009_66b7_4027_f48a), + P64::new(0xccec_bc98_c912_74c1, 0x0009_64a5_6850_b8ed), + P64::new(0x273a_0894_1bb7_1e77, 0x0009_6294_7990_eb36), + P64::new(0xdead_5a1e_3f34_1baf, 0x0009_5fd4_a4c8_85e0), + P64::new(0x83ee_e092_5933_09fd, 0x0009_5dc5_d395_4fde), + P64::new(0x4af5_f1bd_3ae8_7ce9, 0x0009_5c67_1ddf_e516), + P64::new(0x4ca8_5ad2_301c_9e6d, 0x0009_584d_6340_ddf1), + P64::new(0x1b19_592c_d31a_3943, 0x0009_5641_de84_afcc), + P64::new(0x3e7a_a05e_6dcd_81bb, 0x0009_5389_3c38_6521), + P64::new(0x8633_6cec_b02b_a47f, 0x0009_4f77_40d8_7794), + P64::new(0xa96b_30d0_c8a4_4b2b, 0x0009_4e1c_b70c_9ce0), + P64::new(0xb7c6_3fa0_cfca_0571, 0x0009_4962_ecbc_c7ce), + P64::new(0x8eaf_59b4_05a6_42b5, 0x0009_4559_c690_59cf), + P64::new(0xdf29_e9cb_b536_dc17, 0x0009_41ff_7e64_0716), + P64::new(0xed14_132c_82c1_d43f, 0x0009_39fd_7a24_b099), + P64::new(0xaf68_778e_34ca_ab0d, 0x0009_37ff_22c0_14bd), + P64::new(0xa4f0_4a33_6894_1d31, 0x0009_3405_0872_c09e), + P64::new(0xe996_0969_357c_07e7, 0x0009_3209_446d_56f6), + P64::new(0xeb47_b62b_7360_b469, 0x0009_3160_33b5_bd22), + P64::new(0x64c6_53d7_79ae_730f, 0x0009_2a22_b9a7_9374), + P64::new(0x4797_02d3_3199_15c7, 0x0009_2783_8edb_a206), + P64::new(0xef3c_3eeb_c680_3239, 0x0009_21a2_e711_2833), + P64::new(0x9380_7b1a_2e3c_0e1b, 0x0009_1e62_3d56_60d0), + P64::new(0x8167_e33e_3f47_8029, 0x0009_1c6f_c0ca_b8b6), + P64::new(0x60cb_76e3_8c33_9397, 0x0009_17e7_d880_28eb), + P64::new(0xae34_788f_fe4b_c283, 0x0009_169d_4555_85cd), + P64::new(0x4b62_46a0_c6c0_93a5, 0x0009_15f8_1ef2_d529), + P64::new(0x872e_594b_12b0_3efb, 0x0009_1409_3859_5d3a), + P64::new(0xbc0a_e83c_e904_5b15, 0x0009_10d2_360a_450e), + P64::new(0x0ad3_0a39_17e0_968d, 0x0009_0e41_7104_eabd), + P64::new(0x124e_f5a4_e1c7_cd63, 0x0009_0c55_d0fd_ea28), + P64::new(0x5b98_fe0e_9fe1_7aaf, 0x0009_0b0e_84c0_4f20), + P64::new(0x4143_06cf_e454_00fd, 0x0009_0924_3fac_6b70), + P64::new(0xa06d_1b4f_d391_e8bb, 0x0008_ff9d_0440_d137), + P64::new(0x1193_9803_a60c_2381, 0x0008_fb31_9278_9d73), + P64::new(0x668c_11cc_37ea_6b23, 0x0008_f80c_0d50_31e3), + P64::new(0x83f9_b208_9dc1_0645, 0x0008_f76b_3664_f164), + P64::new(0x65dc_8ae4_7af2_77a9, 0x0008_f3a8_0550_abc3), + P64::new(0x6e23_68b9_c685_770b, 0x0008_f087_c50e_00c4), + P64::new(0x3ea1_37ae_ba5a_6b2d, 0x0008_efe7_fb40_8cc2), + P64::new(0x735f_57ad_ca48_f19d, 0x0008_eaec_ce5c_4fd7), + P64::new(0x69a8_de0b_a1b1_8107, 0x0008_ea4d_ccaa_ec0b), + P64::new(0x8fb8_4bdf_5822_bd79, 0x0008_e4ba_9fbc_2ff0), + P64::new(0xb8fa_b3b7_4856_2721, 0x0008_dd56_88a3_b7d6), + P64::new(0xa6c6_58ea_10a6_5c3b, 0x0008_d7d3_821f_d94f), + P64::new(0xe563_81f3_3ab5_e549, 0x0008_d5fe_b03c_31d7), + P64::new(0xe3c2_24da_1498_8139, 0x0008_d120_33cc_9d30), + P64::new(0x438c_253e_6d99_f513, 0x0008_cbac_4dec_6a82), + P64::new(0xc1b9_9f88_41a3_a6e1, 0x0008_c9dc_80ab_604b), + P64::new(0x63fa_18c7_9c54_fa8b, 0x0008_c942_115d_cc96), + P64::new(0xe7f6_f609_619d_0d1d, 0x0008_c3d7_df67_b539), + P64::new(0x7b39_ef3b_70af_c109, 0x0008_c2a4_bc35_cb3b), + P64::new(0x7392_2c61_ca74_52bf, 0x0008_c0d8_a4f1_f264), + P64::new(0x28d9_6828_3323_72c1, 0x0008_c03f_71cb_f906), + P64::new(0x6b6e_9296_8c4e_8463, 0x0008_bd42_abd9_a107), + P64::new(0x5718_61f0_8496_2edb, 0x0008_bae0_51d7_f6ff), + P64::new(0xd935_c64f_140f_1ef5, 0x0008_b7e7_3506_8135), + P64::new(0x9645_9f8f_d72a_4c4b, 0x0008_b61f_82c5_fb08), + P64::new(0x410b_a9a2_a182_42d9, 0x0008_b458_8a74_a05a), + P64::new(0xcf90_979f_8987_0391, 0x0008_b1fb_0a7e_d403), + P64::new(0x10f9_4ff2_6bc0_0add, 0x0008_b0cc_c5d8_f5c8), + P64::new(0xa661_9fbb_9da1_39b3, 0x0008_af07_f8ac_5146), + P64::new(0x765a_2333_4efb_03d5, 0x0008_ae71_328f_fd49), + P64::new(0x6f2f_613b_5e63_1837, 0x0008_ab80_8662_4822), + P64::new(0x666b_99bf_bcd3_68b9, 0x0008_aaea_3ab5_ae89), + P64::new(0x922b_78eb_01ed_45bd, 0x0008_a766_1f70_20fe), + P64::new(0x7079_a199_c31d_e6a9, 0x0008_a63a_b88a_a8dd), + P64::new(0xa181_abcd_a167_be5f, 0x0008_a47a_35d0_20f3), + P64::new(0x2f6d_bbca_b3a9_822d, 0x0008_a2ba_68a3_cebf), + P64::new(0xc5a8_3ff0_e43e_ba17, 0x0008_a225_4c85_2497), + P64::new(0x28c6_8613_dda7_d97b, 0x0008_9ea8_4989_8bb3), + P64::new(0x5cf3_3ed4_9efa_5007, 0x0008_9d7f_3e28_5109), + P64::new(0x9125_fdea_d661_590d, 0x0008_9972_0af3_6739), + P64::new(0xaee6_7f47_8c73_25e7, 0x0008_9442_160d_11dc), + P64::new(0x735b_1274_a0e8_9653, 0x0008_931b_d587_5a22), + P64::new(0x733b_56ea_e1a4_e621, 0x0008_9163_0877_aedf), + P64::new(0x1944_ffb3_16ff_e65d, 0x0008_8baa_ad83_e38f), + P64::new(0xf26b_c3cf_d2a0_1449, 0x0008_8a86_b909_0aa4), + P64::new(0xb582_7ba6_8b83_e201, 0x0008_883f_b99b_f244), + P64::new(0xac13_9507_e48e_efb7, 0x0008_868b_45e7_27ee), + P64::new(0xeb76_76b2_5834_fda3, 0x0008_8568_aef3_0d47), + P64::new(0xad89_8f47_63da_5c1b, 0x0008_8324_68f0_bcdd), + P64::new(0xea90_6f22_4398_f9a7, 0x0008_8202_b9a4_df76), + P64::new(0xa8af_f3ca_ca28_cdad, 0x0008_7e0f_3187_2e9b), + P64::new(0x46c5_3aa3_6b19_b083, 0x0008_7c5e_cd73_1f42), + P64::new(0x9ada_32b0_9603_e8cf, 0x0008_7b3e_ea3b_b388), + P64::new(0xd31f_842e_f5d8_e915, 0x0008_7751_a6c6_7d78), + P64::new(0x6124_af44_730a_33f9, 0x0008_73f6_e2f9_d34a), + P64::new(0x828e_c4c2_b6e6_4a85, 0x0008_72d9_38dc_fc01), + P64::new(0x3d6f_49df_9996_38af, 0x0008_724a_8015_1dba), + P64::new(0x7641_460a_0ea8_9b65, 0x0008_69f6_77f6_cc1a), + P64::new(0x9770_3f98_fb7f_e291, 0x0008_68db_701d_f58d), + P64::new(0xd343_c209_e3e6_b7b9, 0x0008_623f_563a_7d6d), + P64::new(0x4e5f_c01f_6a41_406f, 0x0008_6099_ef0c_8886), + P64::new(0xb78a_05b0_8aa4_bcbd, 0x0008_5ef5_2d38_fe87), + P64::new(0x3434_a149_19d3_4561, 0x0008_5bad_981c_7847), + P64::new(0xccea_d7de_e120_f525, 0x0008_5868_93de_7cfc), + P64::new(0xe137_5a2b_ccd8_7673, 0x0008_549b_491e_9efe), + P64::new(0xf727_d514_20a5_7141, 0x0008_52fb_3859_bea4), + P64::new(0x2c3b_68cf_bceb_b00d, 0x0008_51e6_31fc_08f8), + P64::new(0xda91_e2f3_e175_42f7, 0x0008_515b_c9cd_e5f1), + P64::new(0xb55f_6100_ae95_d6e3, 0x0008_5047_2f61_85b3), + P64::new(0x6a0c_608e_0bba_a975, 0x0008_4b6d_efbc_166b), + P64::new(0xac5f_2fc1_51c0_16cb, 0x0008_49d1_7159_854b), + P64::new(0xb1e5_af81_46e4_d00f, 0x0008_469a_54a2_0645), + P64::new(0x6e28_3d3b_1126_02c7, 0x0008_4476_f940_1ade), + P64::new(0xf9a4_8bcb_76c9_6e55, 0x0008_42dd_2e2d_c25d), + P64::new(0xa776_780c_a4c0_e101, 0x0008_41cc_543f_58cb), + P64::new(0x8d40_a2d4_7d99_c7c5, 0x0008_3e9b_6c3d_f688), + P64::new(0x4ed9_d8a7_aedc_efef, 0x0008_3e13_82f2_2ff9), + P64::new(0x55c5_cf95_8607_2313, 0x0008_3ae5_7a32_7933), + P64::new(0x62c6_40e3_86ef_1f09, 0x0008_32fd_15e0_0939), + P64::new(0xdb87_6e7f_eb8b_02f9, 0x0008_2ecb_9c66_69ac), + P64::new(0x5b85_ac15_58bd_f263, 0x0008_2e45_ba66_52c4), + P64::new(0xb2b1_3930_c2a8_89b1, 0x0008_2cb4_7b00_abaa), + P64::new(0xdf53_c897_124f_8c57, 0x0008_26fa_5d0c_e5aa), + P64::new(0x68a6_9390_fdce_78dd, 0x0008_2359_8cfc_6865), + P64::new(0x5a1e_8f02_61e6_e7b3, 0x0008_21cc_79da_73f1), + P64::new(0xcce3_8a9c_caab_014d, 0x0008_1f37_ff3d_12c0), + P64::new(0xb0cd_4811_fe6a_8171, 0x0008_1c21_947b_0acd), + P64::new(0x911c_2457_3e44_5027, 0x0008_1a97_404a_f5f7), + P64::new(0x9e86_401e_61ca_c4a9, 0x0008_1a13_f02d_110e), + P64::new(0xfd27_3140_5f26_5eb5, 0x0008_190d_81c9_877b), + P64::new(0x3f4c_0020_5c05_b02d, 0x0008_1701_6c0b_3ffd), + P64::new(0xe92e_3d0a_829a_974f, 0x0008_1473_c50a_c33e), + P64::new(0xdec2_16e5_aa47_169d, 0x0008_12ec_59f2_d11a), + P64::new(0xa039_7bf3_448b_cd73, 0x0008_1165_82e2_37c8), + P64::new(0x9ecf_538d_7efa_905b, 0x0008_0b4f_e85e_c545), + P64::new(0xb103_7b5f_8488_6421, 0x0008_07c7_894d_029a), +]; + +//////////////////// Tables for deterministic Miller-rabin bases of 32/64-bit integers based on hashing //////////////////// +/* + * Forišek, Michal, and Jakub Jancina. "Fast Primality Testing for Integers That Fit into a Machine Word." (2015). + * http://ceur-ws.org/Vol-1326/020-Forisek.pdf + * https://people.ksp.sk/~misof/primes/ + */ + +#[cfg(feature = "big-table")] +pub const MILLER_RABIN_BASE32: [u16; 256] = [ + 0x3ce7, 0x07e2, 0x00a6, 0x1d05, 0x1f80, 0x3ead, 0x2907, 0x112f, 0x079d, 0x050f, 0x0ad8, 0x0e24, + 0x0230, 0x0c38, 0x145c, 0x0a61, 0x08fc, 0x07e5, 0x122c, 0x05bf, 0x2478, 0x0fb2, 0x095e, 0x4fee, + 0x2825, 0x1f5c, 0x08a5, 0x184b, 0x026c, 0x0eb3, 0x12f4, 0x1394, 0x0c71, 0x0535, 0x1853, 0x14b2, + 0x0432, 0x0957, 0x13f9, 0x1b95, 0x0323, 0x04f5, 0x0f23, 0x01a6, 0x02ef, 0x0244, 0x1279, 0x27ff, + 0x02ea, 0x0b87, 0x022c, 0x089e, 0x0ec2, 0x01e1, 0x05f2, 0x0d94, 0x01e1, 0x09b7, 0x0cc2, 0x1601, + 0x01e8, 0x0d2d, 0x1929, 0x0d10, 0x0011, 0x3b01, 0x05d2, 0x103a, 0x07f4, 0x075a, 0x0715, 0x01d3, + 0x0ceb, 0x36da, 0x18e3, 0x0292, 0x03ed, 0x0387, 0x02e1, 0x075f, 0x1d17, 0x0760, 0x0b20, 0x06f8, + 0x1d87, 0x0d48, 0x03b7, 0x3691, 0x10d0, 0x00b1, 0x0029, 0x4da3, 0x0c26, 0x33a5, 0x2216, 0x023b, + 0x1b83, 0x1b1f, 0x04af, 0x0160, 0x1923, 0x00a5, 0x0491, 0x0cf3, 0x03d2, 0x00e9, 0x0bbb, 0x0a02, + 0x0bb2, 0x295b, 0x272e, 0x0949, 0x076e, 0x14ea, 0x115f, 0x0613, 0x0107, 0x6993, 0x08eb, 0x0131, + 0x029d, 0x0778, 0x0259, 0x182a, 0x01ad, 0x078a, 0x3a19, 0x06f8, 0x067d, 0x020c, 0x0df9, 0x00ec, + 0x0938, 0x1802, 0x0b22, 0xd955, 0x06d9, 0x1052, 0x2112, 0x00de, 0x0a13, 0x0ab7, 0x07ef, 0x08b2, + 0x08e4, 0x0176, 0x0854, 0x032d, 0x5cec, 0x064a, 0x1146, 0x1427, 0x06bd, 0x0e0d, 0x0d26, 0x3800, + 0x0243, 0x00a5, 0x055f, 0x2722, 0x3148, 0x2658, 0x055b, 0x0218, 0x074b, 0x2a70, 0x0359, 0x089e, + 0x169c, 0x01b2, 0x1f95, 0x44d2, 0x02d7, 0x0e37, 0x063b, 0x1350, 0x0851, 0x07ed, 0x2003, 0x2098, + 0x1858, 0x23df, 0x1fbe, 0x074e, 0x0ce0, 0x1d1f, 0x22f3, 0x61b9, 0x021d, 0x4aab, 0x0170, 0x0236, + 0x162a, 0x019b, 0x020a, 0x0403, 0x2017, 0x0802, 0x1990, 0x2741, 0x0266, 0x0306, 0x091d, 0x0bbf, + 0x8981, 0x1262, 0x0480, 0x06f9, 0x0404, 0x0604, 0x0e9f, 0x01ed, 0x117a, 0x09d9, 0x68dd, 0x20a2, + 0x0360, 0x49e3, 0x1559, 0x098f, 0x002a, 0x119f, 0x067c, 0x00a6, 0x04e1, 0x1873, 0x09f9, 0x0130, + 0x0110, 0x1c76, 0x0049, 0x199a, 0x0383, 0x0b00, 0x144d, 0x3412, 0x1b8e, 0x0b02, 0x0c7f, 0x032b, + 0x039a, 0x015e, 0x1d5a, 0x1164, 0x0d79, 0x0a67, 0x1264, 0x01a2, 0x0655, 0x0493, 0x0d8f, 0x0058, + 0x2c51, 0x019c, 0x0617, 0x00c2, +]; + +#[cfg(feature = "big-table")] +pub static MILLER_RABIN_BASE64: [u32; 16384] = [ + 0x0024_b047, + 0x002e_32a1, + 0x0038_b06b, + 0x0031_d047, + 0x0018_50d3, + 0x0059_5115, + 0x0017_b04f, + 0x001c_f1b1, + 0x002c_502b, + 0x0055_732b, + 0x0014_b137, + 0x001f_315b, + 0x0004_7005, + 0x0011_9005, + 0x0019_10df, + 0x002e_f125, + 0x000a_3029, + 0x0028_708b, + 0x0012_50c7, + 0x001a_5005, + 0x003f_11eb, + 0x0044_9347, + 0x0011_901d, + 0x0028_d02f, + 0x0024_b1a5, + 0x000a_3053, + 0x0003_d029, + 0x002c_5017, + 0x0013_304f, + 0x0013_d10f, + 0x000c_703d, + 0x0003_b005, + 0x000f_10c5, + 0x001c_11b7, + 0x0010_d0ad, + 0x0002_501d, + 0x0021_d101, + 0x0032_917b, + 0x0033_b0e5, + 0x0016_f151, + 0x0017_f0fb, + 0x0028_d0a3, + 0x0025_11fd, + 0x002a_b2a1, + 0x0015_1005, + 0x0006_7043, + 0x0023_9017, + 0x001a_3115, + 0x0010_d095, + 0x002a_1257, + 0x0012_5047, + 0x0033_d03b, + 0x000f_1011, + 0x0013_302f, + 0x002c_f23b, + 0x001e_7049, + 0x0019_117f, + 0x001a_317f, + 0x0016_7049, + 0x0004_3029, + 0x004c_d259, + 0x0029_51bb, + 0x000b_5065, + 0x002b_d25f, + 0x0004_f03b, + 0x0010_1005, + 0x0016_f119, + 0x0010_f0c5, + 0x0033_70e5, + 0x000d_3059, + 0x004e_b36d, + 0x002b_303d, + 0x0048_118d, + 0x001c_f049, + 0x0035_b0a7, + 0x000d_f04f, + 0x0028_d025, + 0x0013_70e9, + 0x0016_1005, + 0x0006_1005, + 0x0028_715d, + 0x0007_1059, + 0x0026_b02f, + 0x000c_7043, + 0x0011_9011, + 0x0004_901d, + 0x0019_9011, + 0x001e_b095, + 0x0013_7005, + 0x0022_d10f, + 0x0004_7005, + 0x0041_b35b, + 0x0017_b095, + 0x002c_f0b5, + 0x0013_9089, + 0x0028_1025, + 0x0005_301f, + 0x000f_b0b3, + 0x0015_d125, + 0x0003_5005, + 0x003f_12d7, + 0x0010_f011, + 0x0030_12e7, + 0x001d_3115, + 0x0004_300d, + 0x0032_b0ad, + 0x001e_70fb, + 0x0017_5095, + 0x000e_90e3, + 0x000e_f07f, + 0x0006_d01f, + 0x001c_f03d, + 0x000f_10bf, + 0x0019_1005, + 0x0037_32ef, + 0x000b_308b, + 0x000e_f09d, + 0x0032_920b, + 0x0013_d047, + 0x0026_b1b1, + 0x0019_103b, + 0x0010_102b, + 0x0033_714b, + 0x003e_5125, + 0x0016_1035, + 0x000b_f059, + 0x000e_f067, + 0x0012_50b3, + 0x0017_502b, + 0x001c_d1c9, + 0x001f_d005, + 0x0009_7071, + 0x0017_b0a7, + 0x0007_f007, + 0x0010_10c1, + 0x000f_1005, + 0x0017_507f, + 0x0010_1007, + 0x0018_5017, + 0x000f_b0e3, + 0x000c_700d, + 0x000d_f00d, + 0x0011_b047, + 0x0016_1029, + 0x0027_715d, + 0x0012_5107, + 0x000e_3067, + 0x001c_104f, + 0x0019_1059, + 0x001c_d007, + 0x000e_f07f, + 0x0005_9049, + 0x0007_f06d, + 0x003f_1295, + 0x0047_f16f, + 0x0035_9065, + 0x0035_f259, + 0x0022_d1cf, + 0x000c_1065, + 0x001a_517f, + 0x0033_51cf, + 0x0030_11cf, + 0x0014_b035, + 0x001f_3035, + 0x003d_f01d, + 0x0008_b083, + 0x001c_d15b, + 0x0009_7083, + 0x0004_3035, + 0x000f_b089, + 0x000a_302f, + 0x0004_301f, + 0x0018_d0fb, + 0x002f_50e5, + 0x0025_723b, + 0x0003_5029, + 0x0006_1017, + 0x0013_d035, + 0x000c_5003, + 0x0010_f047, + 0x0011_906d, + 0x0019_1049, + 0x003f_d1fd, + 0x0006_5025, + 0x001f_d16f, + 0x000f_b0c1, + 0x000f_1095, + 0x0012_5089, + 0x0008_b035, + 0x0006_b03b, + 0x001c_f08b, + 0x002a_b175, + 0x0009_700b, + 0x000d_f0bf, + 0x0022_d003, + 0x0013_90ad, + 0x0035_b0c5, + 0x002d_d101, + 0x001c_f005, + 0x001c_f0fb, + 0x0010_d0a3, + 0x003d_f07f, + 0x001d_30e3, + 0x0037_3185, + 0x0025_71f7, + 0x0012_50d3, + 0x0004_903d, + 0x0028_121d, + 0x0011_5013, + 0x0013_703d, + 0x0017_f101, + 0x0031_d283, + 0x0035_f33b, + 0x0011_9053, + 0x0035_5083, + 0x0035_51c9, + 0x000e_f02b, + 0x0004_900b, + 0x0025_11e7, + 0x000d_30c5, + 0x001b_7067, + 0x0023_b0f1, + 0x0004_f017, + 0x001f_71b7, + 0x0068_5047, + 0x001b_1065, + 0x000a_3049, + 0x001c_11bb, + 0x000e_f005, + 0x000a_300d, + 0x0010_d06d, + 0x0012_5029, + 0x003b_335f, + 0x0022_31fd, + 0x0021_d0f1, + 0x0029_315b, + 0x0016_1125, + 0x0018_5035, + 0x0033_7071, + 0x000a_706b, + 0x000a_7029, + 0x000c_5025, + 0x0022_d175, + 0x000b_3059, + 0x0016_1071, + 0x0009_7017, + 0x001c_107f, + 0x0028_306d, + 0x0040_71bb, + 0x0041_91c1, + 0x0006_b02b, + 0x0022_3137, + 0x0025_103d, + 0x0007_1035, + 0x0009_703b, + 0x0038_b02f, + 0x0006_b01f, + 0x0010_703b, + 0x000e_5083, + 0x000f_1067, + 0x000b_f00d, + 0x004b_d283, + 0x0018_5071, + 0x0023_31f3, + 0x0024_b005, + 0x0019_902f, + 0x0010_d071, + 0x003e_5161, + 0x000a_d035, + 0x0023_90bf, + 0x0012_503b, + 0x0013_300d, + 0x000e_f0b5, + 0x0004_3035, + 0x001a_5133, + 0x002d_d1a5, + 0x0013_710f, + 0x001f_311b, + 0x0019_900d, + 0x0025_911b, + 0x0010_d01f, + 0x0041_b03d, + 0x001a_f0bf, + 0x0028_10f1, + 0x001e_b007, + 0x0018_50d3, + 0x000c_100d, + 0x000f_b065, + 0x000b_5035, + 0x0007_106d, + 0x0024_b0df, + 0x001f_d071, + 0x0055_135b, + 0x000c_109d, + 0x0010_f0d3, + 0x0012_50c7, + 0x003b_9071, + 0x000c_5043, + 0x0035_52b3, + 0x0013_d0ad, + 0x0022_301d, + 0x000c_106b, + 0x000b_503b, + 0x0017_507f, + 0x0044_f0b3, + 0x0045_542d, + 0x0020_9043, + 0x001a_500d, + 0x0019_918d, + 0x0038_f25f, + 0x002b_3119, + 0x0026_503d, + 0x0011_50b5, + 0x001d_f1cd, + 0x0013_d04f, + 0x002e_302f, + 0x0043_f2dd, + 0x0026_b1bb, + 0x003f_b1e7, + 0x003f_124b, + 0x000f_b0c5, + 0x0016_7137, + 0x0032_9133, + 0x0025_7013, + 0x0009_5053, + 0x001c_d061, + 0x0008_907f, + 0x0026_b259, + 0x0011_5017, + 0x0021_d053, + 0x000c_1011, + 0x0013_d011, + 0x003d_715b, + 0x000b_f06d, + 0x0016_70fb, + 0x0023_b0d3, + 0x0008_b083, + 0x000a_d00b, + 0x001e_b167, + 0x000a_306d, + 0x0033_d0f1, + 0x001d_f0fb, + 0x000c_101f, + 0x0017_f025, + 0x000c_70b5, + 0x0026_9067, + 0x002d_d1b7, + 0x0020_b097, + 0x0018_d0ad, + 0x000f_1029, + 0x0029_5071, + 0x000c_1005, + 0x0026_b095, + 0x0007_1035, + 0x0017_f0b5, + 0x0025_f06b, + 0x000b_5083, + 0x0049_d17b, + 0x000e_301d, + 0x0013_311b, + 0x002a_1287, + 0x0008_9071, + 0x0012_5061, + 0x0006_5017, + 0x0017_b01f, + 0x0025_f067, + 0x0055_d0c7, + 0x001b_71af, + 0x0033_d191, + 0x000e_302b, + 0x0014_b0e5, + 0x000a_7053, + 0x0004_703b, + 0x0044_5185, + 0x000a_3043, + 0x0005_901f, + 0x0044_f0fb, + 0x000d_30c7, + 0x000f_b0c7, + 0x001a_f025, + 0x0035_91fd, + 0x000f_b013, + 0x0049_314b, + 0x0015_103b, + 0x0015_b14b, + 0x002c_f185, + 0x0010_f01d, + 0x0010_1011, + 0x001a_5191, + 0x0023_30b5, + 0x003a_900b, + 0x000f_1025, + 0x0029_317b, + 0x0002_5007, + 0x001b_b067, + 0x002b_d295, + 0x000a_d047, + 0x000c_70a7, + 0x000e_f065, + 0x0012_5065, + 0x0029_3119, + 0x002e_7071, + 0x0021_d101, + 0x0034_71eb, + 0x0030_10c7, + 0x0033_704f, + 0x0003_d02b, + 0x003f_b3e5, + 0x0050_315d, + 0x003d_721d, + 0x0017_50c1, + 0x0009_d02b, + 0x0011_904f, + 0x0028_126b, + 0x0047_f1f7, + 0x0035_9167, + 0x0010_f0b3, + 0x002c_5049, + 0x0002_900d, + 0x0017_50f1, + 0x0001_7011, + 0x0084_12cf, + 0x000d_f03b, + 0x0002_5017, + 0x0018_d0b3, + 0x001b_b0f1, + 0x0028_100d, + 0x0005_300d, + 0x0003_b02b, + 0x0028_109d, + 0x0021_d0e5, + 0x0026_b0a7, + 0x0001_f00d, + 0x0027_7071, + 0x000f_b09d, + 0x0051_71b1, + 0x0015_b07f, + 0x0008_9035, + 0x0020_91e7, + 0x0015_10e5, + 0x0010_1025, + 0x005e_7125, + 0x003d_f26b, + 0x0026_b1cf, + 0x000d_306d, + 0x000a_3049, + 0x0023_b089, + 0x003b_3119, + 0x0023_3095, + 0x001a_3053, + 0x0025_710d, + 0x000c_70b3, + 0x0010_f0a3, + 0x0035_532b, + 0x0029_5101, + 0x002e_f1f7, + 0x0009_703d, + 0x0017_b067, + 0x0026_504f, + 0x001b_b191, + 0x0064_d61f, + 0x0010_d09d, + 0x0027_7259, + 0x004f_f33b, + 0x0016_f0df, + 0x0003_502f, + 0x0012_5095, + 0x000a_3003, + 0x0004_703d, + 0x0025_907f, + 0x0056_500d, + 0x000e_307f, + 0x0020_91df, + 0x0006_d017, + 0x002d_d2c5, + 0x0015_101f, + 0x0025_f02b, + 0x0019_10ad, + 0x0005_3029, + 0x002b_d137, + 0x0024_b1b7, + 0x0018_510d, + 0x0020_b161, + 0x001e_71c1, + 0x0044_3329, + 0x001c_d0e9, + 0x003f_b337, + 0x001e_b0d3, + 0x001e_b067, + 0x000d_f095, + 0x001a_f07f, + 0x0034_702b, + 0x000f_b0a3, + 0x0010_d043, + 0x004c_d481, + 0x001f_d1df, + 0x001b_b0b5, + 0x0028_7283, + 0x0016_f0b5, + 0x0035_f0c1, + 0x000c_709d, + 0x000c_706b, + 0x0033_d2f5, + 0x0003_d00d, + 0x0004_f011, + 0x0020_90e3, + 0x000a_3005, + 0x0013_d029, + 0x0008_b003, + 0x002a_52a1, + 0x000e_90ad, + 0x0028_1139, + 0x0022_d191, + 0x0037_735f, + 0x000b_3047, + 0x002f_9151, + 0x0010_f101, + 0x0003_5017, + 0x000d_f0d3, + 0x0052_73b9, + 0x000d_3029, + 0x0014_b115, + 0x0026_b1fd, + 0x0028_1239, + 0x0022_d06d, + 0x001a_f0a3, + 0x0024_b10d, + 0x001b_b107, + 0x0034_72d7, + 0x0010_100b, + 0x0027_70ef, + 0x0011_50f1, + 0x0006_704f, + 0x000e_30df, + 0x0011_5013, + 0x0028_3151, + 0x0004_3025, + 0x0002_b00d, + 0x002b_d259, + 0x0024_b0ad, + 0x0005_304f, + 0x0014_b047, + 0x0017_b0df, + 0x0018_50b5, + 0x000d_3043, + 0x000c_1043, + 0x0023_9107, + 0x0012_5035, + 0x000b_f0a7, + 0x0012_50bf, + 0x000a_701d, + 0x001e_b0b3, + 0x0013_70d3, + 0x0010_f0bf, + 0x0006_1005, + 0x0013_9125, + 0x0015_b029, + 0x0013_906b, + 0x000a_3089, + 0x0013_d00d, + 0x0019_906b, + 0x004c_f065, + 0x0011_900d, + 0x000b_f043, + 0x001a_501d, + 0x0007_101d, + 0x002c_f25f, + 0x0010_100d, + 0x0028_d0e3, + 0x000e_f03b, + 0x000a_703b, + 0x0024_1089, + 0x001b_1025, + 0x0046_335b, + 0x003c_72a1, + 0x0037_1089, + 0x0062_3397, + 0x0058_f125, + 0x0025_90ef, + 0x0019_1043, + 0x000e_906d, + 0x000c_70b5, + 0x0016_f065, + 0x0008_b089, + 0x0029_31f3, + 0x0001_300d, + 0x0011_b0c7, + 0x0040_708b, + 0x001c_10d3, + 0x0042_d1df, + 0x0013_7017, + 0x000d_301d, + 0x002a_510d, + 0x003d_102f, + 0x000e_902b, + 0x0010_1089, + 0x001a_f00b, + 0x0011_5005, + 0x0028_3101, + 0x002d_d02b, + 0x0029_307f, + 0x0006_b00d, + 0x0014_b115, + 0x0016_706d, + 0x001c_1175, + 0x0027_70d3, + 0x001d_301f, + 0x0018_d06d, + 0x001a_5191, + 0x002f_5043, + 0x0035_f295, + 0x000e_30b3, + 0x0011_b067, + 0x0006_7005, + 0x0026_b0a7, + 0x001e_70ad, + 0x0022_30df, + 0x0015_b10d, + 0x0009_d071, + 0x0006_7043, + 0x001c_f06d, + 0x0009_d053, + 0x0016_f03b, + 0x0022_30c1, + 0x0025_f0fb, + 0x0014_b053, + 0x0017_f15b, + 0x0016_f097, + 0x001c_f083, + 0x0013_906d, + 0x001a_30b5, + 0x002e_f1cf, + 0x0023_b17f, + 0x000f_b00d, + 0x001f_30fb, + 0x0019_117f, + 0x0009_706d, + 0x001c_f151, + 0x0027_7185, + 0x0010_108b, + 0x0017_b03d, + 0x0009_d061, + 0x001e_70ad, + 0x0007_f005, + 0x0020_9139, + 0x001b_717f, + 0x0023_308b, + 0x001d_f18d, + 0x0017_f095, + 0x001b_b011, + 0x0051_5301, + 0x0015_10ef, + 0x0048_131d, + 0x0016_f09d, + 0x0033_d259, + 0x0019_90df, + 0x0051_14c1, + 0x000e_506d, + 0x000d_3053, + 0x0026_5061, + 0x001a_30f1, + 0x0013_9049, + 0x0028_7097, + 0x0013_7101, + 0x002a_100b, + 0x001a_5005, + 0x000c_7083, + 0x001a_f125, + 0x001b_1025, + 0x0035_f167, + 0x0024_b095, + 0x0037_32a5, + 0x001c_f071, + 0x0011_b065, + 0x0034_70fb, + 0x0020_b04f, + 0x0033_5265, + 0x0017_b0b5, + 0x0051_501f, + 0x003a_9161, + 0x000d_f0c7, + 0x003b_331d, + 0x0010_f0c1, + 0x0016_106b, + 0x003d_f281, + 0x001e_70fb, + 0x0019_908b, + 0x000a_309d, + 0x0023_901d, + 0x002a_1101, + 0x000c_70b5, + 0x000b_f029, + 0x0016_101d, + 0x0010_d061, + 0x0006_500d, + 0x0016_1115, + 0x0039_721d, + 0x0040_9305, + 0x000d_f0a3, + 0x0021_d06b, + 0x0028_100d, + 0x0027_71df, + 0x001b_b0b3, + 0x001a_314b, + 0x0023_3185, + 0x0013_7011, + 0x0024_1137, + 0x003a_12d7, + 0x0010_10fb, + 0x0040_f20b, + 0x0022_d15d, + 0x0006_1011, + 0x000d_306d, + 0x0028_3139, + 0x0016_7119, + 0x0023_b18d, + 0x0017_b01d, + 0x002b_d295, + 0x0012_500d, + 0x0043_f233, + 0x000d_f09d, + 0x000c_1067, + 0x001f_303d, + 0x000f_b053, + 0x0010_d083, + 0x0033_d06b, + 0x0032_92cf, + 0x004a_940f, + 0x0019_9083, + 0x000b_5049, + 0x0015_d09d, + 0x0013_d01f, + 0x0008_303d, + 0x001c_1017, + 0x0017_f095, + 0x0006_700d, + 0x001c_d15b, + 0x002a_b1a5, + 0x000b_f0b3, + 0x0009_503d, + 0x0042_7017, + 0x001d_30ef, + 0x0025_702b, + 0x000f_b04f, + 0x000e_507f, + 0x0011_50e5, + 0x0006_1005, + 0x0019_902f, + 0x0018_d10d, + 0x0022_30e9, + 0x0009_501d, + 0x001c_d03b, + 0x0041_936d, + 0x0019_9013, + 0x0017_f125, + 0x001a_50e9, + 0x0015_b0c5, + 0x001b_702f, + 0x0004_703b, + 0x0006_1059, + 0x0006_1059, + 0x0028_30fb, + 0x001b_b107, + 0x0031_309d, + 0x000c_50a3, + 0x002e_3277, + 0x001b_10fb, + 0x0030_5029, + 0x0046_340f, + 0x000e_9043, + 0x002f_900d, + 0x0012_50e3, + 0x0029_31f7, + 0x0010_d025, + 0x0013_d0ef, + 0x0006_b01f, + 0x0032_b24b, + 0x0018_5119, + 0x000d_f049, + 0x0019_907f, + 0x003d_7151, + 0x001e_714b, + 0x000c_1017, + 0x0019_918d, + 0x001a_f139, + 0x0012_5059, + 0x0020_911b, + 0x000b_5067, + 0x001f_d0a3, + 0x0016_7125, + 0x0006_b049, + 0x001e_b107, + 0x0024_1101, + 0x000c_7049, + 0x0020_91c1, + 0x002d_d1cf, + 0x001c_101f, + 0x0018_514b, + 0x000d_f0b5, + 0x0011_b013, + 0x0024_11bb, + 0x000b_5005, + 0x000f_b095, + 0x000b_3029, + 0x004f_d22d, + 0x000a_3029, + 0x000d_300d, + 0x0003_501d, + 0x0033_b06d, + 0x0029_30e9, + 0x0008_b065, + 0x0006_d065, + 0x0010_102f, + 0x0008_3029, + 0x0008_b089, + 0x003a_d337, + 0x0006_b035, + 0x001a_3053, + 0x0001_d013, + 0x0019_90c7, + 0x0033_d1df, + 0x0015_d083, + 0x004a_93fb, + 0x0039_7005, + 0x0011_900b, + 0x000f_106b, + 0x0033_d06d, + 0x000e_9067, + 0x0004_902b, + 0x0013_d0a7, + 0x0015_d151, + 0x0029_5259, + 0x0035_917f, + 0x002d_7241, + 0x0004_300b, + 0x0018_d167, + 0x0022_300d, + 0x000b_3005, + 0x0018_d0a3, + 0x002c_525f, + 0x0051_b3c7, + 0x0018_500d, + 0x0010_1025, + 0x0033_70c7, + 0x0006_5025, + 0x0023_b09d, + 0x000f_b09d, + 0x0018_5107, + 0x0008_b065, + 0x000e_f0e5, + 0x0010_d01f, + 0x004c_1469, + 0x0013_3119, + 0x0002_b00d, + 0x003b_31f3, + 0x0026_51c1, + 0x0011_50a7, + 0x000c_70a7, + 0x000e_501f, + 0x0029_31b1, + 0x001a_5017, + 0x0010_10c1, + 0x0015_d139, + 0x000d_307f, + 0x002e_f2c5, + 0x0013_30c1, + 0x001d_30d3, + 0x0011_50c1, + 0x000e_506b, + 0x000b_3005, + 0x001c_115b, + 0x0000_d003, + 0x0008_307f, + 0x0023_b1af, + 0x004c_f133, + 0x0046_91fd, + 0x0031_3025, + 0x001f_d1cd, + 0x0007_f065, + 0x000c_500d, + 0x0030_50e9, + 0x0046_30a7, + 0x0033_b029, + 0x000e_90bf, + 0x0039_735b, + 0x0011_b115, + 0x000f_b01f, + 0x0009_d013, + 0x0016_1005, + 0x002e_317b, + 0x0015_b115, + 0x003f_10c1, + 0x0037_30e9, + 0x001f_3125, + 0x0026_9061, + 0x002f_92b3, + 0x003d_7373, + 0x0049_30e9, + 0x001c_10ad, + 0x0037_3295, + 0x003c_72a1, + 0x0010_1059, + 0x0033_5185, + 0x0001_100b, + 0x000a_d067, + 0x001e_70fb, + 0x001a_314b, + 0x0026_90ef, + 0x0042_70b3, + 0x000b_f007, + 0x0008_9053, + 0x0013_d0a3, + 0x002b_d049, + 0x0028_71f3, + 0x000d_f02f, + 0x0016_7035, + 0x0010_10e5, + 0x000c_100d, + 0x002c_502b, + 0x0028_7035, + 0x0009_d00d, + 0x000c_1003, + 0x0016_f0e9, + 0x0015_b13d, + 0x001a_f089, + 0x0022_d067, + 0x002e_308b, + 0x0004_f02b, + 0x0067_949d, + 0x0039_7059, + 0x001f_3119, + 0x0025_114b, + 0x0019_910f, + 0x0013_7115, + 0x0022_d007, + 0x0024_1049, + 0x0019_100d, + 0x0011_90ef, + 0x0021_d0c7, + 0x002c_f095, + 0x0016_106d, + 0x0010_107f, + 0x0026_915d, + 0x001c_91c1, + 0x0018_503d, + 0x0006_704f, + 0x001b_7029, + 0x000f_b0e9, + 0x0003_5011, + 0x000f_10e5, + 0x001e_b139, + 0x0019_90c5, + 0x0023_91d3, + 0x000e_903d, + 0x0008_902b, + 0x000c_7035, + 0x000a_306d, + 0x0009_7095, + 0x000a_3065, + 0x0018_5005, + 0x0026_5259, + 0x0023_b1df, + 0x0016_10c5, + 0x0009_5065, + 0x0018_513d, + 0x0001_d011, + 0x002d_d233, + 0x0025_9083, + 0x000e_f061, + 0x0051_5043, + 0x001e_70bf, + 0x001a_f0e5, + 0x002b_d21d, + 0x0014_b029, + 0x0025_70df, + 0x001c_f1bb, + 0x0011_9097, + 0x0025_f209, + 0x0017_b0df, + 0x0009_7059, + 0x0036_d04f, + 0x0002_f005, + 0x0012_50df, + 0x0059_9125, + 0x0026_b0fb, + 0x0015_10e5, + 0x002d_d1a5, + 0x001b_714b, + 0x0004_300d, + 0x0026_5107, + 0x0007_1061, + 0x0019_9013, + 0x0040_9161, + 0x0025_90c1, + 0x000d_f083, + 0x004b_136d, + 0x0011_b053, + 0x004f_d0df, + 0x0003_d02f, + 0x002e_702f, + 0x002e_702f, + 0x0032_92f9, + 0x001c_9059, + 0x0004_703b, + 0x002d_d1f7, + 0x0010_1071, + 0x002c_f1bb, + 0x001c_f01f, + 0x0024_1025, + 0x000e_500d, + 0x0017_f10d, + 0x0008_b03d, + 0x002d_d1fd, + 0x0028_7107, + 0x003e_5043, + 0x002e_70ad, + 0x0016_f161, + 0x0009_d08b, + 0x000f_b067, + 0x0010_f029, + 0x0025_1125, + 0x000e_f0c7, + 0x0025_91bb, + 0x0022_d047, + 0x001a_f167, + 0x002a_50ef, + 0x0060_7493, + 0x0011_510f, + 0x003c_7005, + 0x0030_5199, + 0x0008_b005, + 0x0037_10c1, + 0x002f_903b, + 0x0032_9287, + 0x0028_d061, + 0x002b_d107, + 0x0017_f04f, + 0x001c_9095, + 0x0019_102b, + 0x000d_f02b, + 0x001f_302b, + 0x0015_b11b, + 0x000a_3067, + 0x001c_d095, + 0x0014_b10d, + 0x001d_300d, + 0x001c_110f, + 0x0006_b01d, + 0x003f_5265, + 0x0016_f0c5, + 0x0017_b119, + 0x0017_50b5, + 0x0050_30bf, + 0x000d_300d, + 0x0028_3241, + 0x004d_50c7, + 0x0035_90c7, + 0x0022_d1f7, + 0x0032_b2e3, + 0x0028_d005, + 0x0026_91a5, + 0x0025_f01f, + 0x0008_3067, + 0x0028_d1bb, + 0x0026_911b, + 0x0010_f053, + 0x0022_3137, + 0x000b_f00d, + 0x0033_52cf, + 0x0039_7035, + 0x001a_3101, + 0x0032_9175, + 0x0015_d0ad, + 0x0033_b0ad, + 0x0013_90a7, + 0x0009_d025, + 0x0028_70c1, + 0x002f_5133, + 0x0048_b06b, + 0x000b_3005, + 0x000f_1089, + 0x002a_5277, + 0x0019_1097, + 0x001f_70a3, + 0x002d_726b, + 0x0001_f017, + 0x0018_5175, + 0x0009_d02b, + 0x0031_d1a3, + 0x0025_70fb, + 0x0027_70e3, + 0x0031_31fd, + 0x002a_50e5, + 0x001c_f0ef, + 0x0040_902f, + 0x0023_90b3, + 0x0009_7095, + 0x0018_d0ef, + 0x0026_b067, + 0x0026_5241, + 0x0033_d2e3, + 0x0022_d167, + 0x0071_f2b3, + 0x0019_104f, + 0x0028_7003, + 0x0006_504f, + 0x0017_5005, + 0x001f_30a7, + 0x000c_7089, + 0x000b_f065, + 0x0038_f00d, + 0x003f_b2f5, + 0x0002_f00d, + 0x0033_b101, + 0x0009_7049, + 0x000f_102b, + 0x004a_333d, + 0x0011_503b, + 0x0020_b1eb, + 0x0016_f0e3, + 0x0020_b11b, + 0x0022_d01f, + 0x0060_d5b3, + 0x0037_7313, + 0x000c_7097, + 0x0029_315d, + 0x000e_f065, + 0x002a_1293, + 0x000c_1043, + 0x0010_f0e5, + 0x0029_51c9, + 0x000e_f0df, + 0x0035_521d, + 0x006f_1175, + 0x002e_f151, + 0x0028_d047, + 0x0003_5017, + 0x0006_b029, + 0x0012_500d, + 0x0030_110d, + 0x0002_f005, + 0x002f_91bb, + 0x0010_d0e5, + 0x0021_d0ad, + 0x000d_f0c7, + 0x0037_3115, + 0x001a_5043, + 0x0017_b025, + 0x0017_5005, + 0x001a_5065, + 0x000b_5095, + 0x000b_3061, + 0x000c_5083, + 0x0008_3035, + 0x001c_107f, + 0x0025_f107, + 0x001d_30ef, + 0x001d_3107, + 0x0005_9049, + 0x0013_90bf, + 0x0019_10c7, + 0x0059_91cf, + 0x0002_9017, + 0x0016_110d, + 0x0028_30e9, + 0x0016_1139, + 0x0006_5061, + 0x0017_b08b, + 0x001f_710f, + 0x003c_7005, + 0x0036_d06d, + 0x000d_f01f, + 0x0021_d0bf, + 0x000b_5097, + 0x004a_9065, + 0x0001_d017, + 0x001f_318d, + 0x0013_3059, + 0x0028_1259, + 0x0028_7029, + 0x0004_9025, + 0x000c_1083, + 0x0013_30b5, + 0x000c_5029, + 0x0013_9125, + 0x0009_5003, + 0x001f_d167, + 0x0035_50e5, + 0x0005_9017, + 0x002d_d007, + 0x0035_90f1, + 0x004f_f301, + 0x002b_d08b, + 0x003b_331d, + 0x0015_10b5, + 0x000b_306b, + 0x002a_b191, + 0x0028_7223, + 0x0011_b08b, + 0x0009_7005, + 0x000d_f09d, + 0x0011_50d3, + 0x001f_700b, + 0x001a_f061, + 0x000e_50d3, + 0x001c_9029, + 0x0026_b241, + 0x000d_f00b, + 0x001c_f185, + 0x0013_d0e3, + 0x0012_5107, + 0x001b_b0e5, + 0x001f_d1a5, + 0x0028_7281, + 0x001d_f167, + 0x003a_931d, + 0x001f_d005, + 0x001b_100d, + 0x000a_703b, + 0x0015_d025, + 0x0028_31e7, + 0x001c_d133, + 0x0008_900b, + 0x000b_3029, + 0x0030_1259, + 0x0016_f139, + 0x001c_d00d, + 0x000f_b095, + 0x0032_b059, + 0x005d_b33b, + 0x0025_102f, + 0x002a_5293, + 0x0038_f0bf, + 0x0001_100d, + 0x0030_1185, + 0x001a_f0ef, + 0x003f_b241, + 0x0017_b15b, + 0x0008_9083, + 0x000e_30c5, + 0x0013_7047, + 0x002d_720b, + 0x0008_3005, + 0x0006_d029, + 0x000e_90c1, + 0x0015_b0ad, + 0x000e_5025, + 0x0013_d01d, + 0x0010_d0fb, + 0x002d_d1d3, + 0x0009_d06b, + 0x0008_900d, + 0x003d_f005, + 0x0023_b1e7, + 0x0002_f00d, + 0x0030_10c7, + 0x003d_f1fd, + 0x000b_3013, + 0x000c_10b3, + 0x0022_d049, + 0x002b_3293, + 0x0010_700d, + 0x0025_713d, + 0x001f_d191, + 0x001c_f0a3, + 0x000c_50ad, + 0x0046_944f, + 0x0026_5043, + 0x0013_d0ad, + 0x0016_f0e9, + 0x0011_50a7, + 0x000b_5065, + 0x005d_50c5, + 0x0002_f025, + 0x0013_910d, + 0x003c_b0c5, + 0x0006_101f, + 0x0037_136d, + 0x001a_504f, + 0x0008_b00d, + 0x0015_101f, + 0x000c_707f, + 0x001d_3137, + 0x001a_f0e3, + 0x0026_9151, + 0x001b_b0c7, + 0x0006_503b, + 0x000b_302b, + 0x000a_d07f, + 0x003c_7277, + 0x000b_3005, + 0x0007_106d, + 0x0007_f025, + 0x000d_306d, + 0x0006_d005, + 0x0008_3025, + 0x002a_1013, + 0x0036_d269, + 0x0009_503d, + 0x0033_b2e7, + 0x0001_f007, + 0x0010_706d, + 0x002a_100d, + 0x0013_30f1, + 0x005e_73b3, + 0x001b_1043, + 0x002e_3119, + 0x0058_1025, + 0x000f_b01f, + 0x0082_3035, + 0x0025_7223, + 0x000b_f061, + 0x002e_f0c1, + 0x0035_9025, + 0x0017_f125, + 0x002a_5251, + 0x0018_5083, + 0x0022_d1c1, + 0x002a_11a5, + 0x0014_b04f, + 0x0045_5283, + 0x0010_1053, + 0x0028_7005, + 0x0024_10ad, + 0x0015_d15b, + 0x000f_1065, + 0x0019_1097, + 0x0005_303d, + 0x004c_733d, + 0x003f_d269, + 0x0040_9377, + 0x000e_3071, + 0x000d_f00d, + 0x0018_d059, + 0x0028_d265, + 0x0010_f0ef, + 0x0013_9115, + 0x0018_5083, + 0x0025_11eb, + 0x0022_3025, + 0x001b_114b, + 0x001a_5043, + 0x000a_300b, + 0x0023_3005, + 0x0011_b06b, + 0x0010_1035, + 0x002f_5035, + 0x0013_900d, + 0x0025_1137, + 0x0023_91cf, + 0x003b_3373, + 0x0023_30bf, + 0x000d_f02f, + 0x002b_d10f, + 0x0030_517f, + 0x000c_10bf, + 0x001a_f071, + 0x0033_71bb, + 0x002a_b02b, + 0x0009_500b, + 0x0023_9059, + 0x002a_1013, + 0x0041_b33d, + 0x0026_b0b3, + 0x001c_9029, + 0x001e_b185, + 0x0041_9373, + 0x003d_f359, + 0x0018_510f, + 0x002b_d175, + 0x002e_721d, + 0x0016_f0e3, + 0x0006_b01f, + 0x0010_1013, + 0x003f_b2ab, + 0x0023_902f, + 0x0028_1047, + 0x0015_b01d, + 0x0028_d071, + 0x0024_10c1, + 0x001a_315d, + 0x0022_d15d, + 0x0052_70b3, + 0x0026_503b, + 0x0016_f059, + 0x0029_3265, + 0x0043_f0e3, + 0x000e_307f, + 0x000e_3005, + 0x0004_700b, + 0x000a_3047, + 0x001a_f03d, + 0x000a_7013, + 0x0008_b071, + 0x0025_11eb, + 0x000d_f02b, + 0x001a_3067, + 0x0030_10bf, + 0x0026_b233, + 0x000f_1065, + 0x0002_900d, + 0x0008_b06d, + 0x0015_d083, + 0x0040_f33b, + 0x0010_70d3, + 0x0018_d0c1, + 0x001a_f18d, + 0x0025_70e5, + 0x0022_30ad, + 0x0035_b2d7, + 0x000d_3035, + 0x0006_d005, + 0x002c_f11b, + 0x000c_104f, + 0x002e_f1b1, + 0x0025_f101, + 0x0021_d11b, + 0x0013_7125, + 0x0025_91af, + 0x000a_7047, + 0x0029_3137, + 0x002b_3199, + 0x0021_d00d, + 0x002e_3257, + 0x000e_30df, + 0x001b_1119, + 0x000f_1097, + 0x0050_9005, + 0x0013_d139, + 0x0021_d02f, + 0x0010_1025, + 0x0015_d083, + 0x0042_d199, + 0x0032_90a3, + 0x002c_506b, + 0x0019_9137, + 0x0020_b17b, + 0x0031_d00b, + 0x003e_50bf, + 0x0005_9053, + 0x0017_508b, + 0x002e_71cd, + 0x0005_9011, + 0x000b_5089, + 0x0014_b035, + 0x0019_903b, + 0x000b_5061, + 0x0006_b005, + 0x0037_11fd, + 0x0029_5047, + 0x0020_b107, + 0x0018_d083, + 0x0009_d007, + 0x0011_b0e9, + 0x0017_5049, + 0x000b_3053, + 0x0017_b101, + 0x0029_51bb, + 0x003a_12ef, + 0x000e_90a7, + 0x000e_f0e9, + 0x001c_1011, + 0x0019_9029, + 0x0023_b125, + 0x0028_10df, + 0x003b_9049, + 0x000b_301f, + 0x003d_114b, + 0x002f_9161, + 0x001c_d151, + 0x000e_30a7, + 0x0025_9137, + 0x0010_f03d, + 0x0009_d04f, + 0x0033_7003, + 0x0011_b059, + 0x0038_f23b, + 0x001f_317b, + 0x0017_b013, + 0x0008_300b, + 0x0018_5119, + 0x002c_50b3, + 0x0016_101d, + 0x0044_5409, + 0x002b_3295, + 0x0042_73e5, + 0x0002_9011, + 0x0019_90b5, + 0x0006_b067, + 0x0026_503d, + 0x003f_1335, + 0x004b_d26b, + 0x0025_91e7, + 0x0026_b1a5, + 0x0042_d08b, + 0x0017_f017, + 0x0016_f125, + 0x0033_d013, + 0x001e_b005, + 0x0014_b0d3, + 0x0040_70bf, + 0x000e_f0c7, + 0x000d_f08b, + 0x001f_d059, + 0x0017_b139, + 0x000a_302f, + 0x000e_500b, + 0x0005_9005, + 0x001c_d107, + 0x0009_d097, + 0x0041_b1d3, + 0x000b_509d, + 0x000b_3095, + 0x004f_d1c9, + 0x001c_90df, + 0x000a_303b, + 0x0008_b07f, + 0x0041_93cb, + 0x003d_7269, + 0x002a_5259, + 0x0033_7013, + 0x001c_f0b5, + 0x0037_12b3, + 0x0033_72a1, + 0x0015_d071, + 0x0010_101f, + 0x0004_7043, + 0x001e_7025, + 0x001c_f1c9, + 0x0016_10a7, + 0x000a_3071, + 0x001e_700d, + 0x0003_b00b, + 0x0019_902b, + 0x0016_70f1, + 0x0009_d04f, + 0x0011_900d, + 0x002a_1095, + 0x0034_72e3, + 0x000c_502b, + 0x0052_936d, + 0x0001_100b, + 0x0019_9137, + 0x0024_110d, + 0x001a_303b, + 0x0023_922d, + 0x000d_f005, + 0x0061_7409, + 0x0048_10e3, + 0x001a_f03d, + 0x0020_91f7, + 0x0019_10ef, + 0x001b_100d, + 0x000b_f025, + 0x000b_508b, + 0x0019_1185, + 0x0031_d265, + 0x0001_700d, + 0x001c_d161, + 0x0003_d035, + 0x0010_f101, + 0x0025_f06d, + 0x000f_1025, + 0x0008_b03b, + 0x0001_1005, + 0x0022_301d, + 0x0033_5287, + 0x0015_d0ad, + 0x0020_b16f, + 0x000d_3065, + 0x0024_b0c7, + 0x0031_318d, + 0x0022_3043, + 0x0026_91c9, + 0x001e_b011, + 0x0029_3053, + 0x0011_5101, + 0x0017_b02b, + 0x000e_90df, + 0x003c_b1eb, + 0x0029_30c1, + 0x004a_3065, + 0x0033_d175, + 0x0025_71b7, + 0x0045_d161, + 0x000c_500d, + 0x0029_500b, + 0x0014_b017, + 0x0013_3095, + 0x0008_9029, + 0x0028_31df, + 0x001d_3175, + 0x001d_3067, + 0x001b_b15d, + 0x0037_1139, + 0x0024_b095, + 0x001b_70e3, + 0x0018_503d, + 0x0015_111b, + 0x001d_f01f, + 0x0018_d02f, + 0x0013_90d3, + 0x0005_9035, + 0x0016_f137, + 0x002d_72cf, + 0x001f_3115, + 0x004e_b1df, + 0x0001_d013, + 0x0013_30e9, + 0x0015_d071, + 0x001e_7185, + 0x003b_9175, + 0x004e_1185, + 0x0004_7043, + 0x0012_5011, + 0x001b_b013, + 0x000f_b043, + 0x001c_1175, + 0x000f_10bf, + 0x002b_d14b, + 0x000b_3049, + 0x0050_32a5, + 0x000e_3035, + 0x001f_d101, + 0x0015_b01d, + 0x000a_7047, + 0x0018_d13d, + 0x0011_5003, + 0x003b_3059, + 0x0017_500d, + 0x000b_5095, + 0x000c_509d, + 0x004c_d2e3, + 0x0035_9005, + 0x0026_50d3, + 0x0022_3151, + 0x0037_310d, + 0x001b_713d, + 0x0016_f0d3, + 0x0020_b0c7, + 0x002b_30b5, + 0x0006_5043, + 0x0049_d257, + 0x0063_d0e5, + 0x0011_90c5, + 0x0010_d07f, + 0x0003_b01d, + 0x002c_f00b, + 0x0006_101f, + 0x0019_903b, + 0x0003_b02f, + 0x0017_f00d, + 0x0013_30a3, + 0x001f_707f, + 0x0042_706d, + 0x001d_30e5, + 0x0012_50bf, + 0x000c_5067, + 0x0004_9025, + 0x0015_10b3, + 0x003e_502f, + 0x0014_b06d, + 0x0067_933b, + 0x000b_3005, + 0x0007_f00d, + 0x001a_30fb, + 0x001e_b061, + 0x0006_b061, + 0x0040_91a5, + 0x0012_5083, + 0x0013_911b, + 0x000b_503b, + 0x0046_300b, + 0x002b_d097, + 0x0004_302f, + 0x000a_700d, + 0x0008_b00d, + 0x003f_13a1, + 0x0059_3257, + 0x002c_5185, + 0x002c_f1f7, + 0x001e_b0b5, + 0x0019_1059, + 0x0034_7003, + 0x0020_91c9, + 0x0025_f02b, + 0x0035_9259, + 0x001a_f0df, + 0x0051_52a5, + 0x0022_3191, + 0x004f_d1b1, + 0x0020_b151, + 0x0033_7241, + 0x001b_b029, + 0x0013_90a7, + 0x0026_b013, + 0x0016_1095, + 0x0018_d03b, + 0x0016_7007, + 0x001b_b1b1, + 0x003f_5223, + 0x0009_508b, + 0x000f_b095, + 0x0012_5065, + 0x001a_f053, + 0x0007_101f, + 0x001d_30e9, + 0x001b_b053, + 0x0001_d00b, + 0x003a_d08b, + 0x0026_9005, + 0x000a_7013, + 0x0007_f053, + 0x0020_9133, + 0x000a_d005, + 0x0009_d06d, + 0x0006_700d, + 0x0003_b00d, + 0x0023_3059, + 0x0028_71c9, + 0x0019_9083, + 0x000a_702b, + 0x0002_f029, + 0x003d_f1c9, + 0x0022_31af, + 0x0005_9049, + 0x0013_300b, + 0x0011_b03d, + 0x0013_9061, + 0x0016_10d3, + 0x000c_70a3, + 0x0011_9101, + 0x004c_d02f, + 0x000e_9059, + 0x0011_500d, + 0x0001_d00d, + 0x0016_f053, + 0x0018_d119, + 0x000b_3029, + 0x001f_3191, + 0x0033_d2f5, + 0x0006_d035, + 0x0028_10e9, + 0x0041_91c9, + 0x001e_b1cf, + 0x0010_7071, + 0x002f_9067, + 0x0013_d0fb, + 0x000d_f0b5, + 0x000a_d09d, + 0x0015_1049, + 0x000a_7029, + 0x0024_109d, + 0x001d_f00d, + 0x0028_3007, + 0x000c_5005, + 0x0023_904f, + 0x002a_5251, + 0x002b_308b, + 0x000b_f017, + 0x0017_514b, + 0x0020_b0df, + 0x002d_7293, + 0x0009_506b, + 0x0036_d03d, + 0x0006_703b, + 0x0009_7043, + 0x003c_7313, + 0x001b_b0bf, + 0x0038_f2cf, + 0x001f_706d, + 0x0010_1071, + 0x001a_f089, + 0x000d_f053, + 0x0013_d0f1, + 0x000b_3065, + 0x0042_d233, + 0x001a_f043, + 0x0010_d0ad, + 0x001e_71a3, + 0x0016_1043, + 0x0026_910d, + 0x0022_3115, + 0x002e_3095, + 0x0025_f025, + 0x002a_1175, + 0x001f_d1df, + 0x002a_1067, + 0x002b_3011, + 0x002e_f2dd, + 0x001b_70c7, + 0x0013_90ad, + 0x0013_307f, + 0x000c_7029, + 0x0013_700d, + 0x004f_d337, + 0x000f_1059, + 0x001f_3107, + 0x0013_706b, + 0x0007_103b, + 0x0024_b02f, + 0x001d_3003, + 0x0046_3427, + 0x0019_115d, + 0x0019_9175, + 0x0035_b089, + 0x000d_f0d3, + 0x0004_f03b, + 0x001c_d013, + 0x0022_d0c7, + 0x0001_f007, + 0x0004_f00b, + 0x0033_715d, + 0x0023_30ad, + 0x005c_f06b, + 0x0014_b0a3, + 0x0019_900d, + 0x0004_f00d, + 0x001b_104f, + 0x0042_5233, + 0x000b_300d, + 0x000e_f0e5, + 0x0014_b101, + 0x0019_9017, + 0x0006_b005, + 0x0028_d0c1, + 0x0010_10a3, + 0x000c_10b3, + 0x0015_b0d3, + 0x0010_d0e9, + 0x001f_302f, + 0x0035_9191, + 0x003b_302b, + 0x0052_f1e7, + 0x0025_70f1, + 0x0035_b28d, + 0x002f_9209, + 0x0006_1025, + 0x0025_f251, + 0x0004_702b, + 0x0012_50b3, + 0x0006_1043, + 0x0022_3061, + 0x0028_7223, + 0x001c_d083, + 0x000f_b053, + 0x001f_7007, + 0x0016_f06d, + 0x0052_72cf, + 0x001b_1049, + 0x0042_7409, + 0x0020_916f, + 0x0018_d119, + 0x0035_b18d, + 0x000e_500d, + 0x0025_f11b, + 0x0019_118d, + 0x001b_1125, + 0x0012_50bf, + 0x002b_d06d, + 0x0024_b191, + 0x0010_101f, + 0x0002_b00b, + 0x0022_3065, + 0x002f_9191, + 0x005c_952f, + 0x001c_d0ad, + 0x001b_7061, + 0x000a_d01d, + 0x000e_3005, + 0x002f_9191, + 0x000a_7011, + 0x003d_f26b, + 0x0013_d139, + 0x0006_5059, + 0x0035_b2ef, + 0x0028_3071, + 0x001f_d133, + 0x0006_d03d, + 0x0022_d03d, + 0x003a_116f, + 0x001c_9125, + 0x0025_909d, + 0x0010_1029, + 0x002f_52b3, + 0x001c_d0e3, + 0x000c_7095, + 0x000d_f0c5, + 0x0006_101f, + 0x0008_b049, + 0x000b_f095, + 0x000a_708b, + 0x0019_102f, + 0x0029_501f, + 0x0030_51f7, + 0x0022_d175, + 0x0061_10e5, + 0x001b_1119, + 0x000b_f013, + 0x0005_3029, + 0x0017_b029, + 0x000c_70a3, + 0x003b_302b, + 0x001b_b185, + 0x0010_f005, + 0x0007_f00d, + 0x0025_1233, + 0x002a_120b, + 0x004c_f241, + 0x0000_d007, + 0x0015_109d, + 0x000e_3007, + 0x002b_d08b, + 0x001b_102f, + 0x0031_d03b, + 0x0024_11b7, + 0x001b_b199, + 0x0023_b175, + 0x001c_f1a3, + 0x0025_91c1, + 0x000e_f0c7, + 0x001b_b0c7, + 0x0045_5119, + 0x000a_d061, + 0x001a_518d, + 0x001f_7137, + 0x001f_318d, + 0x0004_903b, + 0x0016_1053, + 0x0017_50bf, + 0x0024_122d, + 0x0023_318d, + 0x0002_900d, + 0x0040_7025, + 0x005b_f36d, + 0x001f_704f, + 0x000a_d025, + 0x0035_921d, + 0x001f_7025, + 0x0024_b065, + 0x0001_3005, + 0x0030_1097, + 0x0017_b0fb, + 0x0025_1223, + 0x0018_d07f, + 0x002a_503d, + 0x0020_91f7, + 0x0016_10ad, + 0x0010_d0a7, + 0x0011_500b, + 0x0008_306d, + 0x0020_9013, + 0x001a_5053, + 0x0015_d0e3, + 0x0013_3025, + 0x0009_706b, + 0x001f_d00d, + 0x000c_503d, + 0x0025_915b, + 0x0020_b1b1, + 0x0002_f029, + 0x0018_d06b, + 0x0013_309d, + 0x0023_b1eb, + 0x0031_d1f7, + 0x0040_f209, + 0x0019_9167, + 0x0034_7083, + 0x0022_30c7, + 0x0018_d089, + 0x000b_5005, + 0x002c_f0e5, + 0x001d_f1a3, + 0x000d_306d, + 0x0010_f06d, + 0x0006_b03b, + 0x0017_515b, + 0x000f_10bf, + 0x0005_3011, + 0x002e_306b, + 0x002e_7269, + 0x0006_500d, + 0x002c_f08b, + 0x002a_1281, + 0x0020_9097, + 0x006c_56a3, + 0x005d_143f, + 0x001f_3059, + 0x000d_303b, + 0x005d_1223, + 0x000a_7059, + 0x0016_f065, + 0x001c_d053, + 0x002b_31bb, + 0x0015_d0e3, + 0x003e_506b, + 0x0017_b083, + 0x000b_f08b, + 0x005f_340f, + 0x0004_7011, + 0x0030_1167, + 0x000e_f025, + 0x0022_d185, + 0x002e_3095, + 0x0005_3017, + 0x000a_d03d, + 0x0031_d15b, + 0x001a_30c1, + 0x0033_70bf, + 0x000c_5047, + 0x0031_d269, + 0x0013_701f, + 0x002e_f047, + 0x0030_50c5, + 0x0013_d049, + 0x0013_9083, + 0x002e_7043, + 0x0004_7011, + 0x001e_70b5, + 0x0040_701d, + 0x0015_d00d, + 0x000a_3005, + 0x0031_300d, + 0x0012_5067, + 0x003b_3377, + 0x0009_7043, + 0x001b_10bf, + 0x0029_3241, + 0x0023_b1d3, + 0x001f_71eb, + 0x000c_5025, + 0x0017_b017, + 0x0015_b065, + 0x000a_7089, + 0x001a_500d, + 0x002c_f23b, + 0x0019_90e9, + 0x000d_3025, + 0x0018_d167, + 0x001f_701f, + 0x000d_3053, + 0x0031_3295, + 0x0020_90fb, + 0x000a_d017, + 0x0031_31a5, + 0x001c_10c1, + 0x0018_504f, + 0x0015_b13d, + 0x0013_302b, + 0x003d_f2f9, + 0x0004_701f, + 0x000d_30c7, + 0x001a_5185, + 0x004d_5139, + 0x0019_102f, + 0x001d_f053, + 0x0033_5293, + 0x0004_f02b, + 0x0017_50b3, + 0x0006_d011, + 0x0059_f043, + 0x001f_7139, + 0x0061_f1c1, + 0x0016_109d, + 0x0017_f07f, + 0x002b_d125, + 0x0008_9029, + 0x002a_b119, + 0x002c_50a3, + 0x001e_7191, + 0x000c_106d, + 0x000f_b011, + 0x001b_1013, + 0x0018_50e9, + 0x003b_903b, + 0x001a_303d, + 0x002e_f0a3, + 0x0019_900d, + 0x0005_300d, + 0x0018_5025, + 0x000c_5089, + 0x001f_70fb, + 0x0011_9115, + 0x001c_f1a5, + 0x003a_d32b, + 0x0009_7005, + 0x0019_90c7, + 0x0032_928d, + 0x0022_309d, + 0x000d_f003, + 0x0006_5043, + 0x0006_7011, + 0x000d_f0c1, + 0x0025_1005, + 0x0013_3097, + 0x002e_31b7, + 0x0037_1301, + 0x0015_1083, + 0x0007_1017, + 0x0029_5185, + 0x001d_3137, + 0x0010_7047, + 0x0028_71d3, + 0x0022_31b1, + 0x003e_50df, + 0x0008_b047, + 0x0015_b0df, + 0x0031_d029, + 0x0023_3161, + 0x0016_f14b, + 0x001f_703d, + 0x0004_9047, + 0x0027_70c5, + 0x000c_1095, + 0x003b_30e5, + 0x001a_f067, + 0x0044_5047, + 0x0025_f095, + 0x0007_1025, + 0x000f_1071, + 0x000a_d089, + 0x0025_91b7, + 0x0004_703b, + 0x0035_90d3, + 0x0009_d03b, + 0x0005_3005, + 0x0035_51c9, + 0x0011_b01f, + 0x0020_9043, + 0x0038_b00d, + 0x001a_f071, + 0x0015_1107, + 0x0011_5107, + 0x0042_53fb, + 0x0012_50e5, + 0x0049_d0a7, + 0x0018_d17b, + 0x001c_9065, + 0x001c_f0b5, + 0x0040_91cd, + 0x0031_3095, + 0x0029_523b, + 0x000f_10bf, + 0x0017_501d, + 0x001c_1175, + 0x0013_70ad, + 0x001a_50f1, + 0x0019_115d, + 0x001f_717b, + 0x0006_d005, + 0x001d_f15d, + 0x0019_117b, + 0x0049_d24b, + 0x0019_110f, + 0x000f_100d, + 0x001c_d0a3, + 0x0025_f03d, + 0x0017_b0f1, + 0x0045_d3fd, + 0x0025_f199, + 0x0025_1151, + 0x0015_b03b, + 0x002f_906b, + 0x002e_f061, + 0x0011_b00d, + 0x0011_50b3, + 0x0003_d029, + 0x0022_d0f1, + 0x0000_7005, + 0x0007_f071, + 0x0033_52b3, + 0x0006_5011, + 0x0001_d005, + 0x0009_5017, + 0x000c_106d, + 0x0043_f11b, + 0x0009_d00b, + 0x0031_d18d, + 0x0042_d21d, + 0x0001_300d, + 0x001c_1191, + 0x0010_106d, + 0x0020_91df, + 0x0026_5133, + 0x0015_b0b3, + 0x001b_10a7, + 0x0003_d03b, + 0x0044_9373, + 0x001a_5125, + 0x0028_3209, + 0x002b_d1a5, + 0x0026_514b, + 0x001b_703b, + 0x0020_b02f, + 0x0041_b16f, + 0x002b_308b, + 0x000d_f097, + 0x0003_d00b, + 0x0033_b0e9, + 0x001f_303d, + 0x0029_50c7, + 0x0003_b01d, + 0x000e_f0bf, + 0x001a_f0ef, + 0x0015_b0ef, + 0x0001_300d, + 0x0014_b10d, + 0x002a_b1af, + 0x0025_714b, + 0x005f_31d3, + 0x0020_90ad, + 0x0005_9029, + 0x0020_901d, + 0x0009_d005, + 0x001f_7107, + 0x0011_b047, + 0x0013_902f, + 0x0063_d03d, + 0x0019_1025, + 0x000c_100d, + 0x0020_91a3, + 0x0009_501d, + 0x0010_1007, + 0x001d_f125, + 0x0004_301f, + 0x0002_901f, + 0x0005_3049, + 0x0009_507f, + 0x0000_d00b, + 0x0013_3065, + 0x001b_b0c5, + 0x0032_9089, + 0x0023_90a3, + 0x0023_b067, + 0x0032_926b, + 0x0006_d061, + 0x0018_516f, + 0x0018_5139, + 0x002f_500d, + 0x000c_1025, + 0x000c_1049, + 0x000c_7005, + 0x0013_d025, + 0x000c_706d, + 0x0015_b013, + 0x002d_d01d, + 0x0064_9329, + 0x000e_9035, + 0x0006_7065, + 0x0024_102f, + 0x0005_300b, + 0x002e_700b, + 0x000b_306b, + 0x0029_5125, + 0x001e_714b, + 0x001c_d167, + 0x000f_1005, + 0x000e_3011, + 0x0017_5025, + 0x000b_5089, + 0x0021_d1df, + 0x0035_9065, + 0x0007_104f, + 0x0028_124b, + 0x000e_3053, + 0x0003_502f, + 0x002e_31b7, + 0x0012_507f, + 0x0017_f151, + 0x0020_b125, + 0x0023_3223, + 0x0017_f0ad, + 0x0016_714b, + 0x0012_510d, + 0x0005_9049, + 0x0024_b1a5, + 0x001a_f199, + 0x0009_5067, + 0x0033_d283, + 0x001a_5125, + 0x000f_b097, + 0x0040_f167, + 0x000e_f01f, + 0x001f_713d, + 0x0014_b13d, + 0x001c_f005, + 0x001c_909d, + 0x0042_733d, + 0x0010_1071, + 0x0011_b043, + 0x000f_1005, + 0x0033_5265, + 0x0015_b08b, + 0x000f_1007, + 0x000c_1053, + 0x0030_51cd, + 0x0039_709d, + 0x0018_504f, + 0x0018_d025, + 0x000b_3013, + 0x0004_f01d, + 0x001a_5083, + 0x003c_b377, + 0x000a_d053, + 0x001c_1199, + 0x0033_b1b1, + 0x0025_11d3, + 0x000a_707f, + 0x005e_700b, + 0x0021_d10f, + 0x0034_71a3, + 0x0037_322d, + 0x001d_f071, + 0x003a_d017, + 0x003f_106d, + 0x004a_9419, + 0x0014_b0fb, + 0x0023_90c5, + 0x0037_101f, + 0x0016_707f, + 0x0044_5017, + 0x0028_702b, + 0x000c_1025, + 0x000e_9035, + 0x0019_10f1, + 0x0025_f1bb, + 0x001d_f1a3, + 0x0020_b061, + 0x003d_12bd, + 0x0006_b049, + 0x002e_303d, + 0x0019_9107, + 0x0035_510d, + 0x0021_d1c1, + 0x001e_702f, + 0x000e_300d, + 0x0045_5059, + 0x0045_d2c5, + 0x0025_90c5, + 0x000b_5035, + 0x000f_b03b, + 0x0064_7083, + 0x0017_5125, + 0x0009_5025, + 0x006a_100d, + 0x0015_110d, + 0x0028_10d3, + 0x0032_914b, + 0x001a_51a3, + 0x0013_90a3, + 0x0006_5059, + 0x0015_d119, + 0x006d_f371, + 0x0007_f067, + 0x000b_5035, + 0x0009_d065, + 0x0006_d00d, + 0x0018_d0fb, + 0x0004_f043, + 0x000c_507f, + 0x000f_b0bf, + 0x0010_7095, + 0x0011_5047, + 0x001c_1035, + 0x001c_910f, + 0x0031_3025, + 0x0005_3035, + 0x0017_5029, + 0x0017_f095, + 0x0008_306b, + 0x0004_3005, + 0x0010_f0c5, + 0x002e_31a5, + 0x001d_f00d, + 0x0013_706d, + 0x000b_50a3, + 0x000f_b02f, + 0x001d_3139, + 0x0014_b06d, + 0x0058_149d, + 0x0051_b41b, + 0x000d_f049, + 0x0010_d03b, + 0x000b_3083, + 0x0028_1139, + 0x001f_3065, + 0x0004_301d, + 0x002b_31bb, + 0x002c_5133, + 0x0010_7067, + 0x0017_b097, + 0x006b_b0b5, + 0x0006_d00b, + 0x001c_d18d, + 0x000c_7035, + 0x000a_3007, + 0x0028_d029, + 0x0025_f047, + 0x0042_72e3, + 0x0013_30b5, + 0x001c_f0ad, + 0x000f_1083, + 0x0024_b1bb, + 0x0003_d029, + 0x003e_5065, + 0x0023_b167, + 0x003d_f3d1, + 0x000f_b067, + 0x002d_71e7, + 0x0002_f01d, + 0x0026_b269, + 0x000f_b0a7, + 0x0016_7025, + 0x0026_513d, + 0x0017_f0e9, + 0x0021_d1a5, + 0x0008_b06b, + 0x001c_909d, + 0x0025_f011, + 0x002c_f11b, + 0x002f_91a3, + 0x0013_708b, + 0x002f_510f, + 0x002f_91cd, + 0x0018_d06d, + 0x0017_b017, + 0x0025_f185, + 0x0025_710d, + 0x003a_12a5, + 0x003a_9101, + 0x001b_70b5, + 0x0011_50b3, + 0x000f_b07f, + 0x0025_9083, + 0x0029_3119, + 0x0004_9043, + 0x0006_5053, + 0x0026_b241, + 0x0069_d4d5, + 0x0012_5005, + 0x0014_b119, + 0x0025_7139, + 0x001a_5199, + 0x0026_50e5, + 0x0046_3137, + 0x0044_521d, + 0x0002_5005, + 0x0032_91eb, + 0x001b_1065, + 0x0011_b097, + 0x003f_d185, + 0x0045_5277, + 0x0005_9005, + 0x000f_10b3, + 0x0017_500b, + 0x0003_d03b, + 0x0039_70c1, + 0x0016_f03d, + 0x002b_314b, + 0x007e_b425, + 0x001f_d107, + 0x000e_9049, + 0x001a_f00d, + 0x001c_d00d, + 0x0016_700d, + 0x000e_90ad, + 0x0042_72d7, + 0x0035_f1c1, + 0x001b_70ad, + 0x000a_d071, + 0x000d_f06b, + 0x0002_900d, + 0x0023_315d, + 0x0006_5005, + 0x0009_d029, + 0x000a_7067, + 0x0004_7005, + 0x0018_5107, + 0x0016_f025, + 0x0027_703d, + 0x001b_7029, + 0x0013_d04f, + 0x0036_d223, + 0x000c_109d, + 0x0026_9191, + 0x0006_500d, + 0x001d_f071, + 0x0006_702b, + 0x0002_f00d, + 0x0023_b0e3, + 0x0008_9013, + 0x0004_f035, + 0x001f_3175, + 0x000d_3025, + 0x001d_f003, + 0x002a_5125, + 0x0012_50e5, + 0x0024_1035, + 0x000e_f06b, + 0x001b_b0ad, + 0x0029_320b, + 0x0002_5011, + 0x000c_1053, + 0x0021_d17f, + 0x003f_51b1, + 0x0022_d0c5, + 0x002d_d2a5, + 0x003c_715d, + 0x0062_318d, + 0x0007_1059, + 0x0008_b00d, + 0x0024_11f3, + 0x0028_3281, + 0x000e_f049, + 0x001f_701d, + 0x0004_7025, + 0x0007_f02b, + 0x0018_d01d, + 0x0006_502f, + 0x0067_9581, + 0x001f_3005, + 0x000d_3035, + 0x001b_b119, + 0x0032_90e9, + 0x003a_d2a1, + 0x001c_1115, + 0x000b_f025, + 0x0016_f03b, + 0x0011_b059, + 0x0008_9049, + 0x0009_7059, + 0x0017_f01d, + 0x0010_f03b, + 0x0059_f4bd, + 0x0006_703b, + 0x001d_f035, + 0x0024_b071, + 0x0013_d115, + 0x0025_f097, + 0x0013_d03d, + 0x0022_d1b7, + 0x0048_1029, + 0x0010_d097, + 0x0045_d133, + 0x0023_917b, + 0x000a_d06d, + 0x0011_90b5, + 0x000b_f03b, + 0x001c_9065, + 0x0031_30e9, + 0x001d_3151, + 0x0011_501f, + 0x001a_3185, + 0x0014_b0ef, + 0x0010_f0c5, + 0x001a_3071, + 0x0016_107f, + 0x000e_504f, + 0x001f_d17f, + 0x0004_3029, + 0x0011_508b, + 0x0025_1107, + 0x0022_d1df, + 0x0030_523b, + 0x0050_32b3, + 0x002d_d115, + 0x0033_5061, + 0x0006_b029, + 0x0005_9049, + 0x0058_10b5, + 0x000d_f035, + 0x000a_d08b, + 0x0008_3013, + 0x0017_f139, + 0x0035_50e9, + 0x0037_307f, + 0x0010_d09d, + 0x000f_101f, + 0x000f_1059, + 0x0002_500d, + 0x0028_7175, + 0x0004_7011, + 0x0014_b06d, + 0x0009_d025, + 0x000f_1067, + 0x001a_f15d, + 0x000e_508b, + 0x0016_1137, + 0x000e_9029, + 0x0055_1175, + 0x001c_115b, + 0x001d_310f, + 0x001a_316f, + 0x0029_520b, + 0x0012_5049, + 0x0029_5185, + 0x000d_f02b, + 0x0021_d035, + 0x0007_1059, + 0x0007_f011, + 0x000a_306b, + 0x0020_b097, + 0x0042_50c1, + 0x0032_9251, + 0x0016_70c5, + 0x003f_526b, + 0x000f_b00d, + 0x0006_b059, + 0x0026_9259, + 0x0010_f0c7, + 0x0035_50df, + 0x0017_5115, + 0x0044_5407, + 0x000b_303d, + 0x002e_3095, + 0x000f_b0a7, + 0x001c_1059, + 0x0059_3125, + 0x0016_114b, + 0x0028_3125, + 0x0025_1151, + 0x0010_f0ef, + 0x0025_f1af, + 0x0035_f0e3, + 0x0043_f04f, + 0x001c_900d, + 0x0042_d17b, + 0x0019_1115, + 0x001a_3161, + 0x0012_5095, + 0x003c_b043, + 0x0011_90c1, + 0x0016_102f, + 0x0049_32ef, + 0x002a_1083, + 0x0011_910d, + 0x0025_900d, + 0x0030_5191, + 0x0012_5025, + 0x0022_3101, + 0x003a_d0c5, + 0x003b_9049, + 0x0004_901d, + 0x0035_518d, + 0x0015_1097, + 0x0020_b0c5, + 0x0013_909d, + 0x0021_d137, + 0x000f_b09d, + 0x0015_10c5, + 0x000c_104f, + 0x0016_7161, + 0x0032_b305, + 0x0027_701d, + 0x0006_b049, + 0x0008_b01f, + 0x000f_100d, + 0x0015_d03d, + 0x0022_3185, + 0x0011_50ef, + 0x0033_b10f, + 0x0042_d1df, + 0x0009_508b, + 0x001c_f175, + 0x0002_500d, + 0x0008_b007, + 0x001b_7115, + 0x002b_d119, + 0x0019_101d, + 0x001c_d0e9, + 0x0008_302f, + 0x0005_9049, + 0x002a_106b, + 0x002d_d005, + 0x000b_3049, + 0x0017_511b, + 0x000b_f043, + 0x0008_901d, + 0x000a_d03b, + 0x0018_d175, + 0x0013_7005, + 0x000b_f00d, + 0x0020_b13d, + 0x0025_9209, + 0x0013_d01f, + 0x0023_90d3, + 0x0006_7029, + 0x0023_90a3, + 0x0013_9083, + 0x001f_30ad, + 0x0004_f047, + 0x001c_114b, + 0x000b_f0a3, + 0x0023_b03d, + 0x001b_b08b, + 0x0017_5095, + 0x0082_9649, + 0x0044_f3d7, + 0x0043_f061, + 0x0014_b025, + 0x0027_720b, + 0x0029_301f, + 0x001c_1071, + 0x001b_70df, + 0x0002_b013, + 0x0005_9043, + 0x000c_100d, + 0x000f_b0b3, + 0x0013_903b, + 0x0003_500d, + 0x0014_b09d, + 0x0024_b043, + 0x0007_1053, + 0x001c_90ef, + 0x0018_d03b, + 0x002e_f1cf, + 0x0035_9089, + 0x001c_f0f1, + 0x0012_5011, + 0x0011_90df, + 0x0020_901f, + 0x0023_b01d, + 0x0010_d065, + 0x002f_500d, + 0x0010_d0ad, + 0x0023_b17b, + 0x0010_f053, + 0x0009_503d, + 0x0017_50e5, + 0x0001_300b, + 0x0007_f059, + 0x002b_d09d, + 0x0033_b22d, + 0x0018_5013, + 0x000c_507f, + 0x0008_3049, + 0x0029_5097, + 0x001f_d017, + 0x0023_9209, + 0x0064_93e5, + 0x001f_d013, + 0x000c_506b, + 0x0011_50a7, + 0x0009_7095, + 0x0031_306b, + 0x0009_5003, + 0x000a_d043, + 0x0029_525f, + 0x0025_902f, + 0x001a_f0f1, + 0x0048_b38f, + 0x0017_5043, + 0x001c_f09d, + 0x001d_30ad, + 0x0038_f0ef, + 0x000f_10b5, + 0x001a_5061, + 0x0018_5133, + 0x0025_11eb, + 0x0019_1035, + 0x0016_702b, + 0x0042_510d, + 0x001c_9011, + 0x0011_902b, + 0x0024_115b, + 0x0006_d053, + 0x0019_9035, + 0x0003_b013, + 0x0012_5035, + 0x0006_b01f, + 0x0028_11eb, + 0x0008_9025, + 0x0025_f0d3, + 0x0023_91f3, + 0x001b_115d, + 0x0000_d007, + 0x001e_70d3, + 0x0029_522d, + 0x0010_d071, + 0x0023_3083, + 0x0033_7209, + 0x000b_f061, + 0x003c_b0df, + 0x0008_b01d, + 0x0004_9011, + 0x001f_30fb, + 0x003d_7295, + 0x000f_10e5, + 0x0006_701d, + 0x0008_b01f, + 0x0025_f01f, + 0x0001_300b, + 0x0029_31df, + 0x0010_103d, + 0x0007_f005, + 0x0017_50e3, + 0x0025_f0a3, + 0x0006_5059, + 0x001f_300d, + 0x000c_102b, + 0x0006_5029, + 0x0016_113d, + 0x0001_d005, + 0x0024_b151, + 0x002d_7083, + 0x002a_b167, + 0x000d_f00d, + 0x0032_b0df, + 0x0022_3125, + 0x0013_902b, + 0x0040_92ef, + 0x0015_b02b, + 0x0016_70a3, + 0x0027_71d3, + 0x001f_d1f7, + 0x000e_f0e5, + 0x002e_f0ef, + 0x000e_5005, + 0x0024_b059, + 0x0018_5005, + 0x0032_9269, + 0x004b_d06b, + 0x0006_502b, + 0x0025_f1b7, + 0x003c_7293, + 0x0035_f2ab, + 0x000e_3005, + 0x0029_320b, + 0x0025_71b1, + 0x0024_b10f, + 0x0015_10ef, + 0x0012_5025, + 0x0012_506d, + 0x0017_501d, + 0x002e_314b, + 0x004c_7305, + 0x002b_d23b, + 0x000d_f007, + 0x000a_d053, + 0x0018_5005, + 0x0033_5283, + 0x0003_d005, + 0x0024_10e5, + 0x001c_d011, + 0x0011_9061, + 0x001a_5097, + 0x003d_735b, + 0x0027_715b, + 0x0028_7259, + 0x003f_13c7, + 0x0021_d0df, + 0x000e_900d, + 0x0048_12a5, + 0x0022_3065, + 0x0026_51bb, + 0x0037_1281, + 0x0039_722d, + 0x002f_5095, + 0x0012_5061, + 0x003e_53d7, + 0x001c_106b, + 0x0011_500b, + 0x000f_b00d, + 0x000b_f07f, + 0x000d_f035, + 0x0017_501f, + 0x001a_30b3, + 0x003a_92ab, + 0x000a_7013, + 0x0021_d0df, + 0x0033_717b, + 0x000c_5065, + 0x002d_d139, + 0x002a_102f, + 0x001f_d067, + 0x0064_722d, + 0x0018_515b, + 0x003d_71bb, + 0x002a_b125, + 0x001b_115b, + 0x001c_9025, + 0x001b_1025, + 0x0011_b0e3, + 0x000d_f065, + 0x000a_308b, + 0x000d_30ad, + 0x002e_30d3, + 0x003e_5329, + 0x001d_f0e9, + 0x000a_d01d, + 0x0025_f1a5, + 0x000f_10c5, + 0x000c_502f, + 0x0033_b1cd, + 0x001e_b17b, + 0x001b_7101, + 0x0010_10e3, + 0x001a_3095, + 0x0064_95cb, + 0x0033_715d, + 0x0001_d00d, + 0x002b_31c9, + 0x001b_70c7, + 0x0010_f0c7, + 0x0043_f313, + 0x0060_d175, + 0x0017_b167, + 0x0005_9007, + 0x0041_b09d, + 0x005d_5287, + 0x0030_115b, + 0x0013_d02f, + 0x0011_901d, + 0x0023_30ef, + 0x0015_d125, + 0x0033_d18d, + 0x0004_700d, + 0x0013_3083, + 0x0025_1083, + 0x0010_1017, + 0x0005_9005, + 0x001b_b0a3, + 0x0007_f005, + 0x0022_3191, + 0x003f_51f3, + 0x0015_10e9, + 0x0004_303b, + 0x001d_f0bf, + 0x0050_332b, + 0x0042_51cf, + 0x0011_50c5, + 0x0020_90a3, + 0x0023_30f1, + 0x004f_d3b3, + 0x0032_91b1, + 0x0022_30c5, + 0x000e_3071, + 0x000a_7097, + 0x001c_d0fb, + 0x002a_5061, + 0x000b_30a3, + 0x003a_133b, + 0x0018_500b, + 0x0033_70e5, + 0x000f_b0a7, + 0x0017_b011, + 0x0004_7017, + 0x0026_9049, + 0x0026_51cd, + 0x001a_3097, + 0x0010_f097, + 0x000f_108b, + 0x0009_503b, + 0x001d_30df, + 0x000c_5089, + 0x000a_7061, + 0x000c_503d, + 0x001d_3005, + 0x0010_70df, + 0x000d_30bf, + 0x0028_70e5, + 0x0016_f133, + 0x000f_b0c1, + 0x000b_5097, + 0x000b_5007, + 0x001a_f0bf, + 0x0016_10d3, + 0x001f_d199, + 0x0015_b0a3, + 0x0017_f029, + 0x0009_d061, + 0x0019_1035, + 0x0011_50e5, + 0x0030_5095, + 0x0007_106b, + 0x004b_d15d, + 0x0037_1097, + 0x0016_1005, + 0x003b_3257, + 0x0040_f185, + 0x000e_50c7, + 0x0032_b04f, + 0x001b_70df, + 0x0017_5049, + 0x0026_923b, + 0x0037_702f, + 0x000e_f071, + 0x0031_d151, + 0x001e_b11b, + 0x000b_f03d, + 0x0031_31f3, + 0x0043_f0b5, + 0x000e_5095, + 0x0035_b089, + 0x0011_9089, + 0x0015_10c5, + 0x0013_d007, + 0x0008_b061, + 0x000b_5053, + 0x0018_d107, + 0x000b_306d, + 0x0013_90df, + 0x000c_70bf, + 0x0025_715b, + 0x0006_501d, + 0x0017_5025, + 0x0006_5029, + 0x001d_f0e3, + 0x0015_b017, + 0x000e_f049, + 0x000a_d03d, + 0x0035_506d, + 0x0026_5067, + 0x000f_100d, + 0x0017_50a7, + 0x0011_50a3, + 0x0028_1277, + 0x0033_5269, + 0x0006_b00d, + 0x0031_d119, + 0x0011_9017, + 0x0009_5049, + 0x0035_b2c5, + 0x000c_702f, + 0x0016_f065, + 0x000c_102b, + 0x0043_f2cf, + 0x0021_d059, + 0x0004_9005, + 0x0025_90c5, + 0x0025_100d, + 0x0032_b199, + 0x000e_508b, + 0x0028_703d, + 0x0002_f005, + 0x0051_143f, + 0x0008_b017, + 0x000c_1007, + 0x000e_506d, + 0x000c_10ad, + 0x0011_b0ad, + 0x0016_f11b, + 0x0002_900d, + 0x000a_d06b, + 0x0006_b005, + 0x001e_7029, + 0x0025_71f3, + 0x0006_5007, + 0x0003_5013, + 0x0033_b2f5, + 0x0003_d005, + 0x0019_90c5, + 0x002c_f17f, + 0x0009_d02f, + 0x0034_72d7, + 0x002c_f07f, + 0x0038_f33b, + 0x001d_f139, + 0x0035_5005, + 0x0022_d043, + 0x000c_1059, + 0x001e_b09d, + 0x003c_b061, + 0x001c_d199, + 0x0011_9013, + 0x000e_f061, + 0x002a_b16f, + 0x0016_108b, + 0x002c_50ef, + 0x0011_b04f, + 0x0041_b0c5, + 0x0016_107f, + 0x0008_9053, + 0x0033_50c7, + 0x0035_5259, + 0x002e_71a3, + 0x0010_7047, + 0x001e_70c1, + 0x004a_902b, + 0x000a_3043, + 0x001a_30c7, + 0x0017_f017, + 0x000d_3097, + 0x0033_5269, + 0x001b_b0bf, + 0x0010_d059, + 0x001f_3005, + 0x003a_9119, + 0x001f_d133, + 0x0020_9137, + 0x001c_11bb, + 0x0021_d01f, + 0x001c_9043, + 0x0016_f03d, + 0x001b_71af, + 0x0061_720b, + 0x0010_7035, + 0x0012_50e3, + 0x000e_9067, + 0x0010_d029, + 0x0005_9049, + 0x001a_5161, + 0x0003_d01f, + 0x0028_7025, + 0x000e_90b5, + 0x0016_710d, + 0x0036_d251, + 0x001c_d115, + 0x0035_5259, + 0x001c_d035, + 0x0009_5049, + 0x0016_111b, + 0x001f_31a5, + 0x000b_3097, + 0x001e_71a3, + 0x0009_7007, + 0x0008_b03b, + 0x0036_d035, + 0x001c_d0c1, + 0x000b_5071, + 0x0051_b083, + 0x0013_7067, + 0x001c_1043, + 0x002b_3151, + 0x0004_9003, + 0x000c_1083, + 0x0061_1527, + 0x0025_9101, + 0x0000_d007, + 0x0010_d04f, + 0x000e_f04f, + 0x0006_b065, + 0x0028_d0b3, + 0x0002_501d, + 0x000b_3089, + 0x0057_710f, + 0x0017_b07f, + 0x0015_1095, + 0x0027_71c9, + 0x001e_7133, + 0x0006_d065, + 0x001a_501d, + 0x001b_71b1, + 0x0025_7005, + 0x0025_722d, + 0x0006_d035, + 0x0011_9005, + 0x0013_d025, + 0x0018_5119, + 0x0005_900b, + 0x0035_91b7, + 0x002a_5061, + 0x0010_d043, + 0x0023_909d, + 0x002e_70df, + 0x0020_b097, + 0x0064_70e3, + 0x0022_d133, + 0x0028_7223, + 0x003a_1137, + 0x0011_90c5, + 0x001f_d04f, + 0x000d_f095, + 0x005b_f3a1, + 0x0006_7025, + 0x0023_b185, + 0x0017_50e9, + 0x000a_d01d, + 0x000b_f0b3, + 0x001a_f167, + 0x0000_d007, + 0x004b_116f, + 0x0033_510d, + 0x003a_d1c1, + 0x0013_d049, + 0x0015_b005, + 0x0011_5013, + 0x0020_9139, + 0x0019_9013, + 0x0025_f0b3, + 0x0046_9101, + 0x0005_903d, + 0x002e_f241, + 0x004d_501d, + 0x0018_d175, + 0x001e_70fb, + 0x002e_30b5, + 0x0009_7043, + 0x0000_7005, + 0x0001_d013, + 0x000f_1047, + 0x001e_b005, + 0x0005_302b, + 0x0010_70c7, + 0x000c_709d, + 0x0010_d01d, + 0x001e_b0a3, + 0x0096_b005, + 0x0017_b0ef, + 0x000d_3089, + 0x0021_d133, + 0x001e_7061, + 0x0010_703d, + 0x0015_b01d, + 0x0025_1161, + 0x0018_5065, + 0x0013_30f1, + 0x0013_3083, + 0x0025_709d, + 0x0010_d00d, + 0x002a_11af, + 0x003d_113d, + 0x0010_70f1, + 0x0026_9199, + 0x0006_b01d, + 0x0017_f011, + 0x0011_50e5, + 0x0034_7133, + 0x0005_9007, + 0x000c_507f, + 0x0012_510d, + 0x0017_502b, + 0x000b_306d, + 0x0038_f257, + 0x0044_9355, + 0x0005_901d, + 0x001d_30c1, + 0x001b_10c1, + 0x0004_903d, + 0x0015_d02f, + 0x000a_d095, + 0x0012_50c5, + 0x003b_9281, + 0x0006_100d, + 0x0021_d107, + 0x001e_b07f, + 0x0017_5133, + 0x004b_d0a7, + 0x0013_301d, + 0x000a_3043, + 0x0020_b005, + 0x0013_909d, + 0x0019_9007, + 0x000c_5029, + 0x0033_d0f1, + 0x0035_92a5, + 0x002c_51b1, + 0x001a_f061, + 0x0028_108b, + 0x001f_7025, + 0x0035_b03b, + 0x0030_106d, + 0x0017_50c1, + 0x000c_103b, + 0x002d_7251, + 0x0017_503d, + 0x0016_1005, + 0x0006_b03d, + 0x0025_9241, + 0x0028_324b, + 0x0014_b029, + 0x0007_100d, + 0x000e_303b, + 0x0010_70ef, + 0x0018_d161, + 0x002a_10bf, + 0x0003_d01f, + 0x0017_b025, + 0x0020_b1fd, + 0x0017_510f, + 0x0034_701f, + 0x0015_d10d, + 0x001c_f0ef, + 0x0006_701d, + 0x000f_10e3, + 0x000c_101d, + 0x0028_325f, + 0x0017_508b, + 0x0003_b029, + 0x001a_5047, + 0x0004_f017, + 0x0051_7503, + 0x0033_701f, + 0x0010_7101, + 0x000e_f07f, + 0x0045_5065, + 0x0012_502b, + 0x0024_b061, + 0x0033_5199, + 0x001c_f071, + 0x003d_11a5, + 0x0016_f115, + 0x0011_5013, + 0x0013_d0e9, + 0x0020_9043, + 0x0022_306d, + 0x0025_9101, + 0x000a_3003, + 0x002d_7067, + 0x0015_106d, + 0x001d_f15b, + 0x0055_1029, + 0x001c_109d, + 0x0007_f025, + 0x0031_d0a3, + 0x0005_9047, + 0x002b_3101, + 0x0011_9053, + 0x0006_501f, + 0x0022_d16f, + 0x0044_938f, + 0x0023_916f, + 0x0032_903d, + 0x000c_1017, + 0x0025_71af, + 0x006d_f067, + 0x0013_70a3, + 0x000d_303b, + 0x0022_311b, + 0x0004_900d, + 0x001f_3065, + 0x0014_b071, + 0x002c_511b, + 0x001c_117f, + 0x0025_f029, + 0x0033_7029, + 0x0005_3013, + 0x0009_7061, + 0x0024_b005, + 0x004d_528d, + 0x000c_700b, + 0x001a_5167, + 0x002f_506d, + 0x005d_1265, + 0x0033_b0bf, + 0x002d_d107, + 0x0023_90a3, + 0x001f_3089, + 0x0007_1005, + 0x001f_717b, + 0x0050_925f, + 0x005c_90bf, + 0x0009_5065, + 0x0035_5137, + 0x0013_906b, + 0x000b_5061, + 0x0023_9053, + 0x003f_53e5, + 0x0035_b0a7, + 0x0046_33a1, + 0x0025_90c5, + 0x002e_3209, + 0x0025_90d3, + 0x0017_5005, + 0x0028_7025, + 0x001e_7167, + 0x000e_30b5, + 0x004d_5223, + 0x0013_703d, + 0x0033_7305, + 0x0035_515b, + 0x001b_1043, + 0x000e_f04f, + 0x0028_1209, + 0x000e_3005, + 0x001b_711b, + 0x001c_f167, + 0x0011_501d, + 0x0010_d0c7, + 0x0022_30f1, + 0x000a_d04f, + 0x004b_d013, + 0x0016_7097, + 0x001e_b1cd, + 0x0040_90e3, + 0x0028_70ad, + 0x0010_f06d, + 0x0030_50a3, + 0x0029_5005, + 0x001c_900d, + 0x000f_b08b, + 0x0009_502b, + 0x001d_304f, + 0x0013_30c1, + 0x0033_5053, + 0x0033_7101, + 0x0014_b0ef, + 0x001c_9067, + 0x0015_d02b, + 0x0042_d2d7, + 0x000c_5053, + 0x004a_9277, + 0x0006_b013, + 0x0015_b013, + 0x0013_d0ad, + 0x000e_3053, + 0x000b_3005, + 0x001b_10e3, + 0x001d_30b3, + 0x0022_d00b, + 0x000f_b0a3, + 0x0042_5355, + 0x002c_501f, + 0x0013_903d, + 0x001d_309d, + 0x000b_308b, + 0x0021_d1cd, + 0x0017_f097, + 0x0023_306b, + 0x0013_900d, + 0x0001_f00d, + 0x0012_50f1, + 0x000a_3095, + 0x0005_9049, + 0x0021_d0e9, + 0x000e_306d, + 0x0003_b013, + 0x0021_d17b, + 0x0011_5097, + 0x0004_901f, + 0x001a_5125, + 0x0040_902b, + 0x002f_500d, + 0x0016_115b, + 0x000e_f053, + 0x0010_d013, + 0x0031_d02b, + 0x0050_b1bb, + 0x0022_d083, + 0x002a_b28d, + 0x0028_318d, + 0x0013_3043, + 0x005c_f067, + 0x0005_3029, + 0x0025_10c1, + 0x0020_b1b7, + 0x0007_f067, + 0x001c_917f, + 0x0050_b41b, + 0x000c_5053, + 0x0011_9089, + 0x0015_10a3, + 0x003f_1115, + 0x0020_91b1, + 0x0022_3133, + 0x001f_7011, + 0x001c_d097, + 0x0018_d133, + 0x000e_f053, + 0x0010_103b, + 0x0003_5007, + 0x000d_f013, + 0x0017_b059, + 0x0016_70e3, + 0x002b_3259, + 0x000c_1017, + 0x0013_3071, + 0x003d_7209, + 0x0012_510d, + 0x0016_f00d, + 0x000a_709d, + 0x0017_f061, + 0x0011_5083, + 0x0029_51f3, + 0x0026_518d, + 0x000e_307f, + 0x0030_121d, + 0x0030_5067, + 0x0010_1035, + 0x0013_d0d3, + 0x0025_1059, + 0x001c_f06b, + 0x0031_3175, + 0x0023_922d, + 0x0028_3061, + 0x0000_b003, + 0x0016_7107, + 0x001f_715b, + 0x002d_d0f1, + 0x0006_b005, + 0x0009_d02b, + 0x0041_91e7, + 0x000d_f095, + 0x0031_3013, + 0x001b_7083, + 0x000a_d03b, + 0x000d_f071, + 0x002c_f01f, + 0x001a_5005, + 0x0010_f06b, + 0x000e_3053, + 0x000b_303b, + 0x001a_30b5, + 0x003c_71cd, + 0x0016_f043, + 0x0032_9017, + 0x0006_b005, + 0x0006_b005, + 0x0006_700d, + 0x0017_b097, + 0x001f_d1a5, + 0x001b_10b5, + 0x001f_d0bf, + 0x0018_5017, + 0x004c_14a3, + 0x000f_10c5, + 0x000e_508b, + 0x001e_717f, + 0x0014_b133, + 0x003e_53c7, + 0x0006_102f, + 0x001b_110f, + 0x002d_d23b, + 0x000a_3029, + 0x0006_7059, + 0x0006_7013, + 0x000f_b0e9, + 0x000b_f065, + 0x0010_103d, + 0x0013_30f1, + 0x000e_f025, + 0x000e_903d, + 0x0015_b059, + 0x0025_900d, + 0x0035_b01d, + 0x0015_b00d, + 0x000a_707f, + 0x0040_f11b, + 0x000c_1029, + 0x0023_b061, + 0x000c_7013, + 0x003b_3101, + 0x001d_315d, + 0x0016_108b, + 0x0013_7003, + 0x0015_b101, + 0x0031_d24b, + 0x001b_b133, + 0x0003_b005, + 0x0029_503d, + 0x0016_70e9, + 0x0013_d0ef, + 0x0010_d067, + 0x0029_51b1, + 0x002a_5125, + 0x0033_b287, + 0x0029_317f, + 0x0010_f0a7, + 0x001f_d06b, + 0x002c_50bf, + 0x002c_f1f7, + 0x002a_b089, + 0x003a_91d3, + 0x0018_5017, + 0x0010_103d, + 0x0032_92e7, + 0x0022_d14b, + 0x0022_3119, + 0x000d_3013, + 0x0028_3265, + 0x0013_d03d, + 0x0039_7161, + 0x0014_b133, + 0x0012_5007, + 0x0008_301d, + 0x0015_d043, + 0x000c_10a3, + 0x0018_5065, + 0x0027_7013, + 0x0037_7335, + 0x0007_1025, + 0x0011_50a7, + 0x001e_70f1, + 0x0016_101d, + 0x0019_9065, + 0x002f_910f, + 0x0004_900b, + 0x000b_3061, + 0x001b_70ad, + 0x0052_f16f, + 0x0003_d00d, + 0x0035_9139, + 0x001c_9137, + 0x0011_90e3, + 0x0017_b14b, + 0x002e_f097, + 0x0006_b04f, + 0x0008_9071, + 0x0015_10b5, + 0x0003_d007, + 0x0026_9065, + 0x004f_f133, + 0x001b_709d, + 0x0046_9313, + 0x003f_5161, + 0x0008_b089, + 0x0007_f02f, + 0x0014_b01d, + 0x001b_b025, + 0x0020_90c1, + 0x001a_515b, + 0x001c_1029, + 0x0001_300b, + 0x0031_d2e3, + 0x002b_3283, + 0x0042_526b, + 0x0025_921d, + 0x001c_91c1, + 0x0017_5107, + 0x0034_7067, + 0x0014_b0b3, + 0x0008_300b, + 0x0016_10b5, + 0x0010_d005, + 0x0010_10b5, + 0x0002_b011, + 0x0045_d0b5, + 0x0033_5071, + 0x000e_f0c5, + 0x0004_303d, + 0x0015_b043, + 0x002b_d007, + 0x002e_32d7, + 0x0023_b15d, + 0x000b_3047, + 0x0034_72e7, + 0x0004_3025, + 0x000c_5005, + 0x0032_b0ad, + 0x0017_50c5, + 0x0037_31fd, + 0x0010_d03b, + 0x0029_317b, + 0x0008_b02f, + 0x002b_d0fb, + 0x001e_7049, + 0x0006_b025, + 0x0004_901f, + 0x0015_1125, + 0x0019_1005, + 0x0011_503b, + 0x002b_3115, + 0x0013_70a7, + 0x0017_5061, + 0x0011_50df, + 0x001b_b0e9, + 0x0015_b049, + 0x0016_10ef, + 0x002e_701f, + 0x001c_f06b, + 0x001a_30b3, + 0x0020_b115, + 0x0055_1115, + 0x0029_30fb, + 0x0042_d199, + 0x0023_b137, + 0x001c_10d3, + 0x0026_5241, + 0x0013_7049, + 0x003c_b119, + 0x0035_f295, + 0x000b_5059, + 0x001a_f18d, + 0x0001_f017, + 0x001f_71c9, + 0x001e_b0ef, + 0x0015_d013, + 0x003b_9167, + 0x0023_3151, + 0x0011_5029, + 0x0038_b1bb, + 0x0008_b053, + 0x001c_d047, + 0x0011_50df, + 0x0028_3043, + 0x0013_703b, + 0x0037_3167, + 0x0028_325f, + 0x0008_301d, + 0x001f_d0ad, + 0x0029_51cd, + 0x000a_302f, + 0x000e_906b, + 0x0012_50df, + 0x001f_d1f7, + 0x002d_7047, + 0x0013_d00d, + 0x0015_1029, + 0x0007_1049, + 0x0013_9097, + 0x000b_f01f, + 0x0006_1059, + 0x000f_100d, + 0x0010_d0c7, + 0x0004_7025, + 0x0013_70d3, + 0x0005_9025, + 0x0017_b00d, + 0x0010_d01f, + 0x0024_1139, + 0x001a_f06b, + 0x0013_d053, + 0x0010_7005, + 0x0010_f03d, + 0x0023_b067, + 0x0008_b089, + 0x0034_72bd, + 0x002e_f0e3, + 0x0016_f119, + 0x001c_109d, + 0x001b_7175, + 0x0011_5003, + 0x002f_52bd, + 0x000d_f0c1, + 0x002a_1167, + 0x000e_5017, + 0x002b_30fb, + 0x000c_104f, + 0x0015_110f, + 0x0010_f06d, + 0x0007_102b, + 0x0059_f061, + 0x0006_500d, + 0x000a_d02b, + 0x000e_f00d, + 0x0006_500d, + 0x000b_5047, + 0x0017_f0e5, + 0x000a_d053, + 0x0034_70f1, + 0x0038_b31d, + 0x0010_f03d, + 0x0023_9137, + 0x0028_100d, + 0x003a_1287, + 0x000a_d065, + 0x001a_314b, + 0x000c_1097, + 0x000e_3053, + 0x0006_d067, + 0x001c_d067, + 0x0026_51f7, + 0x002c_f17f, + 0x0024_11af, + 0x0011_b115, + 0x0027_716f, + 0x0030_11cd, + 0x0016_108b, + 0x0036_d0c1, + 0x0012_5043, + 0x001e_b133, + 0x006c_d683, + 0x0015_d0e9, + 0x001a_f017, + 0x0059_34cf, + 0x0013_7005, + 0x001d_3005, + 0x0012_50a7, + 0x000f_b04f, + 0x0042_d059, + 0x001f_d06d, + 0x0033_5239, + 0x006a_335b, + 0x001b_1025, + 0x0011_9011, + 0x0016_101f, + 0x003a_1137, + 0x0015_b053, + 0x0025_7191, + 0x0013_910d, + 0x0015_103b, + 0x0017_f17b, + 0x0011_506d, + 0x0015_1139, + 0x0008_9067, + 0x001f_3119, + 0x000b_3011, + 0x0010_d02f, + 0x0009_d02f, + 0x001c_f01f, + 0x001d_f191, + 0x002b_3137, + 0x0016_7071, + 0x004b_1133, + 0x0004_700d, + 0x0012_50ad, + 0x0013_3017, + 0x0013_303d, + 0x000f_1053, + 0x0017_f025, + 0x001c_f0d3, + 0x0044_f089, + 0x0020_b02b, + 0x0011_9007, + 0x0018_5047, + 0x0006_b011, + 0x000d_304f, + 0x0016_100b, + 0x0010_7011, + 0x0016_708b, + 0x0004_3035, + 0x002f_5125, + 0x0011_5059, + 0x001e_70a3, + 0x0002_9005, + 0x0018_d0df, + 0x0018_509d, + 0x0016_f15d, + 0x003a_10f1, + 0x000f_b043, + 0x000b_502f, + 0x000e_9005, + 0x0002_900d, + 0x0001_7005, + 0x0016_7161, + 0x000f_103b, + 0x0006_d03b, + 0x0027_700b, + 0x001c_d04f, + 0x0040_918d, + 0x0023_9047, + 0x001c_d059, + 0x0027_70e5, + 0x0022_d14b, + 0x0013_702f, + 0x000d_303d, + 0x000d_f06d, + 0x0031_315b, + 0x0032_9301, + 0x0018_d02b, + 0x002b_3115, + 0x0026_b0e3, + 0x0013_3013, + 0x0004_303b, + 0x000b_f007, + 0x0012_50ad, + 0x0004_701d, + 0x0022_d0ef, + 0x002d_720b, + 0x0019_1133, + 0x002a_510f, + 0x0010_1059, + 0x0027_7107, + 0x003d_f293, + 0x0003_b01d, + 0x0014_b0b5, + 0x0032_91c9, + 0x001a_5011, + 0x000c_5067, + 0x0010_7013, + 0x0013_301f, + 0x000a_300d, + 0x0000_d005, + 0x0035_b10f, + 0x001c_f199, + 0x001f_70bf, + 0x0011_501f, + 0x0036_d097, + 0x0010_1071, + 0x000a_7013, + 0x0016_1049, + 0x0017_b047, + 0x0006_d02b, + 0x0024_11df, + 0x0017_b025, + 0x002c_510f, + 0x0008_b007, + 0x0011_50a7, + 0x000a_707f, + 0x001a_514b, + 0x0006_101d, + 0x001f_706d, + 0x0004_9025, + 0x0024_1151, + 0x0008_3013, + 0x001e_71bb, + 0x0028_31c9, + 0x0022_318d, + 0x0018_502b, + 0x0012_50c1, + 0x002b_3083, + 0x0024_b053, + 0x0059_f029, + 0x0006_7059, + 0x0017_f0a3, + 0x002c_50a3, + 0x002c_f1cf, + 0x0013_9065, + 0x0009_d025, + 0x0019_109d, + 0x001f_71cd, + 0x0006_7029, + 0x0013_70c1, + 0x0012_50c7, + 0x000e_f067, + 0x000a_3011, + 0x0019_10fb, + 0x0002_f01d, + 0x0035_90fb, + 0x000e_301d, + 0x000e_301d, + 0x002a_5151, + 0x001d_3005, + 0x0044_51b7, + 0x0024_1089, + 0x002e_310f, + 0x0011_900b, + 0x001c_1017, + 0x001c_1043, + 0x000f_b0e5, + 0x0027_709d, + 0x001a_5035, + 0x0040_7049, + 0x0010_7005, + 0x000b_30ad, + 0x0013_d00d, + 0x0026_b083, + 0x001e_b029, + 0x001c_d167, + 0x001e_70e5, + 0x0035_f2ab, + 0x000e_3043, + 0x0009_d043, + 0x0005_3017, + 0x0016_1067, + 0x001c_9083, + 0x0014_b025, + 0x001c_f119, + 0x001a_f083, + 0x0044_53fd, + 0x0042_d3fd, + 0x0021_d1a5, + 0x003a_d03d, + 0x0014_b01f, + 0x0001_7013, + 0x002b_d1cf, + 0x0037_3083, + 0x003d_f15b, + 0x001c_f02b, + 0x0005_9035, + 0x0026_5137, + 0x0010_706d, + 0x0002_901f, + 0x0016_1007, + 0x004c_732b, + 0x0046_31af, + 0x0025_9191, + 0x002a_b133, + 0x002d_d053, + 0x0018_d0d3, + 0x001c_1089, + 0x000a_3049, + 0x0017_f14b, + 0x003f_b013, + 0x0032_b269, + 0x003f_d10f, + 0x0041_9059, + 0x000f_1035, + 0x0024_b11b, + 0x0016_101d, + 0x001e_713d, + 0x0005_9005, + 0x003b_933b, + 0x0008_307f, + 0x0015_d151, + 0x0011_9059, + 0x000e_f025, + 0x0013_7013, + 0x001c_1059, + 0x000b_3053, + 0x0016_f049, + 0x004b_1151, + 0x0045_51eb, + 0x0011_b03d, + 0x004c_103d, + 0x0010_f005, + 0x001c_f0e5, + 0x0041_918d, + 0x0022_3199, + 0x000e_50c1, + 0x002e_f0b3, + 0x0014_b005, + 0x000c_101d, + 0x0011_b095, + 0x0033_520b, + 0x000e_906d, + 0x0015_b0c7, + 0x0035_523b, + 0x0035_f115, + 0x0044_f22d, + 0x0017_b0e5, + 0x0015_10c1, + 0x0008_b061, + 0x0033_51cd, + 0x003f_5137, + 0x001e_b175, + 0x0011_b047, + 0x0024_b167, + 0x000d_3013, + 0x0040_9005, + 0x0024_1151, + 0x000f_b005, + 0x003b_9293, + 0x000a_7049, + 0x0005_9005, + 0x000c_5005, + 0x0010_f0a7, + 0x001c_9035, + 0x003e_535f, + 0x000d_f07f, + 0x0009_d059, + 0x002b_306b, + 0x0022_d049, + 0x0016_10e3, + 0x002c_510d, + 0x005d_502f, + 0x0011_b03d, + 0x001f_31bb, + 0x0010_d0fb, + 0x0009_700d, + 0x000e_300d, + 0x002a_108b, + 0x0017_f03b, + 0x0033_70c1, + 0x0001_d017, + 0x0016_f08b, + 0x0010_10e5, + 0x0061_15f3, + 0x0019_10e9, + 0x003e_5335, + 0x0009_5049, + 0x0019_1043, + 0x0034_71b1, + 0x0028_704f, + 0x000e_5095, + 0x000b_3007, + 0x0026_5239, + 0x0004_f049, + 0x000b_5061, + 0x0026_518d, + 0x0025_f043, + 0x001d_303d, + 0x000d_3065, + 0x001d_f0c5, + 0x000e_50a7, + 0x0017_b15d, + 0x0011_5061, + 0x0018_50a3, + 0x0004_702f, + 0x0017_b0e9, + 0x003d_7355, + 0x0028_108b, + 0x0025_f1d3, + 0x001a_f005, + 0x0005_900d, + 0x0003_d00d, + 0x0013_d025, + 0x0017_f0e5, + 0x0022_d01d, + 0x0024_107f, + 0x002f_90df, + 0x0048_11b1, + 0x0013_70fb, + 0x0009_5035, + 0x0028_3017, + 0x0057_72f9, + 0x000a_3071, + 0x0014_b0a3, + 0x0011_b04f, + 0x002a_5175, + 0x0013_7095, + 0x0028_d083, + 0x0030_50d3, + 0x000e_3095, + 0x001e_b0c7, + 0x0013_9107, + 0x0023_31a5, + 0x000a_3005, + 0x0008_9025, + 0x0026_515b, + 0x004e_b3e5, + 0x0026_5067, + 0x001b_10df, + 0x000e_f0bf, + 0x0015_10d3, + 0x000c_708b, + 0x0018_50b5, + 0x0035_92a1, + 0x0019_9005, + 0x0002_5013, + 0x0011_906b, + 0x000d_3071, + 0x002c_f13d, + 0x0006_d061, + 0x003a_d01f, + 0x0030_1061, + 0x003f_501d, + 0x0003_5025, + 0x001b_b059, + 0x0025_7047, + 0x0023_9151, + 0x002a_1101, + 0x001a_f137, + 0x0039_71cd, + 0x0003_b005, + 0x002e_f1b7, + 0x0024_1199, + 0x0002_f01f, + 0x000e_9025, + 0x000e_901f, + 0x0037_1175, + 0x0013_70d3, + 0x002e_32b3, + 0x000a_3025, + 0x001b_10ef, + 0x0007_f02f, + 0x001f_3059, + 0x000c_5025, + 0x001a_5047, + 0x000c_501f, + 0x0035_f329, + 0x0025_9257, + 0x004c_7053, + 0x0007_f061, + 0x001b_700b, + 0x0013_90c5, + 0x001a_f191, + 0x001f_706b, + 0x0038_b313, + 0x0035_9029, + 0x002e_7047, + 0x0037_10a7, + 0x0029_30b3, + 0x0028_700d, + 0x000a_300d, + 0x000a_303d, + 0x0020_9011, + 0x0019_1175, + 0x0009_d03d, + 0x0018_d061, + 0x0017_b0d3, + 0x0015_b0e3, + 0x002b_d005, + 0x0026_b0bf, + 0x002c_50e3, + 0x000f_1059, + 0x0013_908b, + 0x0004_9025, + 0x0005_3029, + 0x0006_7043, + 0x0015_d02b, + 0x000f_b06b, + 0x0008_901f, + 0x002e_f017, + 0x000d_307f, + 0x002a_5125, + 0x0065_3427, + 0x0000_7005, + 0x0020_915d, + 0x0030_1167, + 0x0076_15a7, + 0x000c_102f, + 0x0030_1125, + 0x0040_9097, + 0x0037_7025, + 0x0006_b00b, + 0x0001_100b, + 0x0024_b097, + 0x001e_70e5, + 0x002a_5067, + 0x000a_303b, + 0x0006_103b, + 0x002e_7283, + 0x0034_7017, + 0x000c_7035, + 0x000b_3007, + 0x0036_d1b7, + 0x007b_b6b9, + 0x0035_90e9, + 0x0012_510f, + 0x0032_9269, + 0x0007_f043, + 0x0041_91b7, + 0x0028_11b1, + 0x0010_102b, + 0x0028_7029, + 0x0018_506b, + 0x0036_d161, + 0x003c_7061, + 0x0036_d035, + 0x0033_d07f, + 0x0017_b0e3, + 0x0034_72dd, + 0x0016_f059, + 0x0008_300b, + 0x000e_f01d, + 0x0030_12ab, + 0x0017_500d, + 0x0003_d005, + 0x0020_918d, + 0x0018_d03d, + 0x0004_f02b, + 0x0013_301d, + 0x0026_5047, + 0x003f_b313, + 0x002c_f0ad, + 0x0002_b011, + 0x0008_3071, + 0x003a_d265, + 0x002a_1071, + 0x001c_f0f1, + 0x002d_d083, + 0x001c_1151, + 0x0001_3007, + 0x0021_d1f7, + 0x0010_d0a3, + 0x0028_10a7, + 0x0033_50df, + 0x0013_d0fb, + 0x0024_b0c5, + 0x0035_9029, + 0x0027_710f, + 0x000d_3025, + 0x000c_503d, + 0x002a_11c9, + 0x003f_11b7, + 0x000b_f059, + 0x0010_70c5, + 0x0025_f199, + 0x0008_3049, + 0x001d_f01d, + 0x0020_9035, + 0x001a_50ad, + 0x0018_d10d, + 0x0022_30c5, + 0x0028_1047, + 0x002f_91a5, + 0x000e_f06d, + 0x0007_1007, + 0x001a_3017, + 0x000b_509d, + 0x0011_9107, + 0x0004_9047, + 0x0024_b15b, + 0x0002_b003, + 0x0042_d335, + 0x0006_1011, + 0x001b_1059, + 0x001e_704f, + 0x001a_317b, + 0x003d_71d3, + 0x001b_b15b, + 0x0010_10df, + 0x0014_b02b, + 0x0006_1005, + 0x0017_f02f, + 0x001c_901d, + 0x0016_f043, + 0x0013_d0f1, + 0x0015_d017, + 0x0023_b239, + 0x0030_51f7, + 0x001a_f011, + 0x001b_1061, + 0x0010_1097, + 0x0001_d00d, + 0x004f_d481, + 0x0013_d0e3, + 0x001b_1151, + 0x001a_f059, + 0x0006_b025, + 0x000f_1097, + 0x0015_b139, + 0x0024_b09d, + 0x0035_f20b, + 0x0023_b1c1, + 0x0004_900d, + 0x0010_1061, + 0x001b_70fb, + 0x0007_f061, + 0x004f_d1df, + 0x0011_50e5, + 0x0015_101d, + 0x0013_70ad, + 0x0017_b0fb, + 0x0010_f08b, + 0x0004_f025, + 0x000a_d06d, + 0x000b_f071, + 0x001d_f0f1, + 0x0062_b26b, + 0x001a_3097, + 0x0011_5067, + 0x000a_3089, + 0x0004_f007, + 0x005d_5277, + 0x0017_b00d, + 0x002e_300d, + 0x001a_3101, + 0x001d_3097, + 0x0025_f1b7, + 0x0009_508b, + 0x000f_1047, + 0x0001_1005, + 0x0041_90c1, + 0x001a_3115, + 0x0049_d161, + 0x000c_50b5, + 0x0000_7005, + 0x003f_1035, + 0x0018_d01d, + 0x001f_d0e9, + 0x0036_d151, + 0x000e_300b, + 0x0021_d119, + 0x0015_d03d, + 0x0010_104f, + 0x003b_32f5, + 0x0048_b1bb, + 0x0044_f097, + 0x0009_5005, + 0x001c_f10d, + 0x0019_1071, + 0x0026_90b3, + 0x0037_106b, + 0x0051_51d3, + 0x0003_b011, + 0x0013_9043, + 0x0008_9029, + 0x002f_90b5, + 0x0019_9025, + 0x0006_1005, + 0x0010_d02b, + 0x0021_d18d, + 0x0004_3005, + 0x0005_9049, + 0x0007_1059, + 0x0005_901d, + 0x0023_900d, + 0x0044_9175, + 0x0004_f007, + 0x0028_306b, + 0x0016_103d, + 0x000e_9043, + 0x0004_302b, + 0x0015_d043, + 0x001d_31af, + 0x0017_502b, + 0x001a_510f, + 0x003f_5359, + 0x0017_b175, + 0x0025_70a7, + 0x001d_f199, + 0x000b_f049, + 0x0017_50c5, + 0x001c_1107, + 0x002d_d1cf, + 0x002d_71b1, + 0x001b_71af, + 0x0006_b01f, + 0x0005_9005, + 0x0011_903d, + 0x0010_d01d, + 0x0026_9029, + 0x003a_d083, + 0x0020_90d3, + 0x0008_3047, + 0x000b_5003, + 0x0019_110d, + 0x0005_9005, + 0x0013_303b, + 0x0011_b07f, + 0x002f_513d, + 0x0025_f06b, + 0x001b_b053, + 0x0013_300d, + 0x0016_10e3, + 0x000f_b0a7, + 0x0008_9011, + 0x001b_71af, + 0x001a_f17f, + 0x0004_902b, + 0x002d_70e5, + 0x0002_501d, + 0x0031_d2dd, + 0x0007_f035, + 0x0028_10c7, + 0x0026_90b3, + 0x003b_9335, + 0x0015_1035, + 0x001a_5185, + 0x0013_7067, + 0x0028_7097, + 0x002b_303b, + 0x001b_b107, + 0x0006_1043, + 0x0004_3005, + 0x0026_911b, + 0x003d_71cf, + 0x0010_1005, + 0x0038_f25f, + 0x0006_5025, + 0x001b_b097, + 0x000a_d02b, + 0x0037_1167, + 0x000d_f035, + 0x0028_113d, + 0x0013_70c1, + 0x001c_f0df, + 0x0010_f005, + 0x0017_5071, + 0x0018_d01d, + 0x0009_d00d, + 0x003c_70a7, + 0x000c_10b3, + 0x000e_308b, + 0x0025_f167, + 0x000a_707f, + 0x0007_f017, + 0x0013_d00d, + 0x001e_b1d3, + 0x002c_51a3, + 0x002c_f083, + 0x0024_1095, + 0x0002_f013, + 0x001e_7161, + 0x0023_90f1, + 0x0009_703d, + 0x0011_5061, + 0x001b_7119, + 0x0031_3209, + 0x0008_306d, + 0x000b_5049, + 0x005f_b2c5, + 0x001d_f139, + 0x0009_5047, + 0x0016_f017, + 0x0023_b1b1, + 0x001d_f10f, + 0x0025_f23b, + 0x0031_d0ad, + 0x0015_10d3, + 0x0015_b061, + 0x002e_3283, + 0x001f_700d, + 0x0005_9029, + 0x0039_7107, + 0x001c_f0e9, + 0x0016_10ef, + 0x000f_b059, + 0x001f_d15d, + 0x0014_b0a3, + 0x000f_b071, + 0x0009_5065, + 0x0020_9199, + 0x0006_503b, + 0x0025_f02f, + 0x000b_3061, + 0x004a_30b3, + 0x0010_d0f1, + 0x000c_7089, + 0x0041_9119, + 0x0013_3125, + 0x0023_91fd, + 0x001b_b06b, + 0x000a_d0a7, + 0x0010_70e5, + 0x0010_f0f1, + 0x001f_d06d, + 0x002f_92dd, + 0x0024_114b, + 0x0013_300d, + 0x0031_31c1, + 0x001b_109d, + 0x003d_f0df, + 0x000a_3067, + 0x003f_138b, + 0x001f_3083, + 0x0008_b025, + 0x0009_d025, + 0x0018_5107, + 0x001f_3071, + 0x0025_10a3, + 0x0030_12e3, + 0x0004_f003, + 0x0009_5071, + 0x001f_7061, + 0x0018_d01d, + 0x0027_70e9, + 0x001b_b191, + 0x001d_309d, + 0x0013_9071, + 0x001c_d011, + 0x003c_b139, + 0x002c_5005, + 0x001f_71df, + 0x004e_b1b1, + 0x0007_100b, + 0x000e_309d, + 0x0008_900d, + 0x0010_70fb, + 0x0011_900d, + 0x005a_d223, + 0x0006_500d, + 0x0010_703d, + 0x000c_703b, + 0x0026_9059, + 0x0049_d31d, + 0x0013_70c7, + 0x003b_32cf, + 0x0059_300d, + 0x0025_f1eb, + 0x001c_d0d3, + 0x008d_b1f3, + 0x0023_300d, + 0x0010_d01d, + 0x0026_b047, + 0x0018_d005, + 0x0019_115b, + 0x0024_115d, + 0x001c_f017, + 0x0020_b1f7, + 0x002a_b269, + 0x0005_300d, + 0x0006_d00d, + 0x001c_f185, + 0x0015_b139, + 0x002d_d047, + 0x0029_5005, + 0x000d_309d, + 0x0029_515d, + 0x0018_d08b, + 0x0013_3067, + 0x002c_f053, + 0x004c_f0e3, + 0x000f_b025, + 0x0055_d463, + 0x0028_d029, + 0x0004_f03d, + 0x000b_507f, + 0x002e_3053, + 0x0010_d0f1, + 0x001b_b139, + 0x004a_90b5, + 0x001a_303d, + 0x0024_b003, + 0x001c_101d, + 0x002c_506b, + 0x000c_5025, + 0x0008_300d, + 0x004f_f133, + 0x0018_d095, + 0x000d_f07f, + 0x0030_1005, + 0x001b_101f, + 0x0012_501f, + 0x0035_9337, + 0x0016_f053, + 0x002e_f295, + 0x0028_110f, + 0x0050_915b, + 0x0011_b095, + 0x0004_701d, + 0x0005_303d, + 0x003e_5167, + 0x0027_7259, + 0x0025_9071, + 0x0008_3035, + 0x0007_104f, + 0x001a_f10f, + 0x0013_9107, + 0x0017_b013, + 0x002c_52a5, + 0x0027_7199, + 0x003c_7071, + 0x0010_f02f, + 0x001f_30df, + 0x0016_703b, + 0x001a_f15b, + 0x0024_1065, + 0x0028_300d, + 0x000b_f083, + 0x000c_502b, + 0x0005_3035, + 0x0019_1013, + 0x000d_30b5, + 0x002a_b14b, + 0x002a_51bb, + 0x002f_518d, + 0x0027_710d, + 0x001b_715d, + 0x0026_90a7, + 0x0002_501f, + 0x003b_90f1, + 0x0027_7125, + 0x0009_5013, + 0x0005_3025, + 0x002c_521d, + 0x0016_711b, + 0x001a_511b, + 0x0032_b01d, + 0x002f_50ef, + 0x003c_b1f3, + 0x001f_3137, + 0x000c_701d, + 0x000e_90e3, + 0x0035_5025, + 0x0015_b137, + 0x000c_1005, + 0x0010_10d3, + 0x001c_110d, + 0x0020_b199, + 0x001a_5167, + 0x0025_f0e3, + 0x000a_d089, + 0x0009_d00d, + 0x0009_d07f, + 0x0032_b107, + 0x000a_302b, + 0x002a_101d, + 0x0015_1083, + 0x000c_702f, + 0x0001_100d, + 0x0025_f199, + 0x000e_502b, + 0x0011_50bf, + 0x001c_f00d, + 0x0057_740f, + 0x0003_d035, + 0x001f_71a5, + 0x0013_30e3, + 0x0008_902f, + 0x0044_3191, + 0x0016_f0e9, + 0x003f_501d, + 0x001b_1005, + 0x002b_d0c7, + 0x009f_d949, + 0x000d_f0ad, + 0x0028_71fd, + 0x000c_100d, + 0x000c_700d, + 0x0031_30ef, + 0x001a_50df, + 0x005a_b2a1, + 0x0016_1137, + 0x0017_b06b, + 0x0008_900d, + 0x000e_f0c7, + 0x0025_700b, + 0x0008_901f, + 0x0026_502b, + 0x000c_50ad, + 0x000d_f03d, + 0x0018_507f, + 0x0029_51df, + 0x0012_50bf, + 0x001f_718d, + 0x001d_f15d, + 0x0018_50a3, + 0x001f_703b, + 0x0009_500b, + 0x0037_100d, + 0x001e_b1e7, + 0x001e_7167, + 0x0028_111b, + 0x0013_3101, + 0x003c_b1e7, + 0x0002_b007, + 0x000a_3089, + 0x0009_5013, + 0x002a_1067, + 0x0028_317b, + 0x001a_5115, + 0x0017_b013, + 0x0018_d185, + 0x000c_50a7, + 0x0013_70fb, + 0x0030_1293, + 0x0026_916f, + 0x0044_f2ef, + 0x0010_f089, + 0x001d_30e9, + 0x003a_d0d3, + 0x002f_9035, + 0x003f_b18d, + 0x001c_1199, + 0x0008_b025, + 0x0010_101d, + 0x0029_306b, + 0x0006_b007, + 0x000b_f011, + 0x001c_d0e3, + 0x0026_b083, + 0x001f_d017, + 0x0025_f107, + 0x0019_104f, + 0x002a_10c1, + 0x0013_30e3, + 0x0055_11e7, + 0x0011_500d, + 0x003d_7397, + 0x0033_501d, + 0x000a_d02f, + 0x001b_b059, + 0x0025_71bb, + 0x0035_f26b, + 0x0017_f059, + 0x000c_7067, + 0x0025_9101, + 0x0051_1107, + 0x0017_b0d3, + 0x002f_92c5, + 0x0017_5119, + 0x0004_9003, + 0x001d_f137, + 0x0016_7059, + 0x0020_90c5, + 0x0006_7043, + 0x0030_10fb, + 0x0010_1011, + 0x0023_b1cf, + 0x0032_b287, + 0x0017_f10f, + 0x0016_1053, + 0x0013_3029, + 0x0019_9115, + 0x000b_50b3, + 0x000f_1003, + 0x0030_50e9, + 0x001c_10e3, + 0x0018_5101, + 0x0018_50e9, + 0x000f_b011, + 0x001a_301d, + 0x003f_b329, + 0x0026_525f, + 0x0028_30ef, + 0x000f_b0ef, + 0x0076_103d, + 0x0039_72e3, + 0x000a_300b, + 0x002c_5053, + 0x005f_b10d, + 0x0042_d3fd, + 0x0062_3005, + 0x000f_b06d, + 0x0015_b02b, + 0x000e_f01d, + 0x001f_3167, + 0x002c_f16f, + 0x003a_915d, + 0x0024_1115, + 0x000d_f065, + 0x0051_13e5, + 0x000c_70c5, + 0x0008_3017, + 0x000e_30b5, + 0x0019_103d, + 0x001a_30f1, + 0x0026_90fb, + 0x0000_d003, + 0x0017_f17b, + 0x0020_b1fd, + 0x0030_52a5, + 0x0016_706d, + 0x0037_1025, + 0x0021_d1fd, + 0x0012_502f, + 0x0010_10df, + 0x000f_102b, + 0x0042_7013, + 0x0037_3257, + 0x0016_7029, + 0x0009_d049, + 0x005d_10ef, + 0x001c_d10f, + 0x002d_7047, + 0x000f_100d, + 0x001e_b06b, + 0x000c_70c1, + 0x0029_5049, + 0x0002_9007, + 0x001f_d049, + 0x0028_7125, + 0x001b_b125, + 0x0011_50fb, + 0x0025_100d, + 0x002e_f083, + 0x0006_503b, + 0x0050_b313, + 0x001a_3059, + 0x000e_50e3, + 0x0013_d02b, + 0x0002_900d, + 0x0001_7013, + 0x0006_b00b, + 0x0023_b01d, + 0x0009_503d, + 0x002f_515d, + 0x0003_d00b, + 0x0028_d1eb, + 0x0011_908b, + 0x001d_f061, + 0x0019_10ef, + 0x0010_10a7, + 0x001c_9185, + 0x0016_1133, + 0x0006_1043, + 0x001b_1005, + 0x000a_7089, + 0x000e_30b5, + 0x000e_3005, + 0x001c_f0c1, + 0x0006_b067, + 0x000b_f07f, + 0x000e_906b, + 0x008f_95f3, + 0x0030_510d, + 0x000d_f01d, + 0x0010_d029, + 0x001d_3029, + 0x0007_f005, + 0x0021_d07f, + 0x0023_b223, + 0x0010_107f, + 0x0010_f0c1, + 0x003f_d0df, + 0x0030_1139, + 0x0020_b095, + 0x000a_7011, + 0x000e_90c1, + 0x001a_3083, + 0x0020_b0c7, + 0x0007_f00d, + 0x0026_b0e5, + 0x0008_3047, + 0x0026_9101, + 0x0005_3011, + 0x0006_b053, + 0x0021_d119, + 0x0019_90ad, + 0x002f_52b3, + 0x001b_1083, + 0x002b_d083, + 0x0024_1209, + 0x0018_5167, + 0x000e_308b, + 0x0038_f199, + 0x0007_f00d, + 0x0030_10b3, + 0x000e_50b5, + 0x001e_7029, + 0x0023_90e9, + 0x0022_d0c5, + 0x0026_516f, + 0x003b_301f, + 0x0005_902f, + 0x0019_117f, + 0x003a_1281, + 0x000d_3043, + 0x002d_d0a3, + 0x0018_5007, + 0x0009_5005, + 0x0026_90a7, + 0x0009_700d, + 0x000b_f01f, + 0x0011_5029, + 0x0017_b139, + 0x002a_113d, + 0x001f_709d, + 0x0015_d10d, + 0x0010_70df, + 0x0009_503d, + 0x001c_10b3, + 0x001e_b005, + 0x0028_d137, + 0x0002_b029, + 0x0017_5071, + 0x0032_91d3, + 0x003b_909d, + 0x0060_7293, + 0x002d_d11b, + 0x0025_1005, + 0x0025_9043, + 0x001c_107f, + 0x0011_5025, + 0x0025_10c5, + 0x004c_f0a7, + 0x001a_f0e5, + 0x001a_5007, + 0x0026_510f, + 0x0022_d1e7, + 0x0013_7049, + 0x0024_10d3, + 0x003f_d335, + 0x0037_1049, + 0x0022_d0c5, + 0x001e_b17f, + 0x0025_f259, + 0x003e_5101, + 0x0039_70e3, + 0x0024_b025, + 0x004e_117b, + 0x0023_3191, + 0x0010_f0e9, + 0x0011_900b, + 0x000a_706b, + 0x0001_f013, + 0x000f_b061, + 0x0028_109d, + 0x000c_10a3, + 0x0035_b067, + 0x0015_d09d, + 0x0026_50ad, + 0x001b_104f, + 0x000b_f01f, + 0x0052_725f, + 0x0008_b005, + 0x0007_f02f, + 0x0033_7239, + 0x0010_d061, + 0x000a_3005, + 0x000e_30c7, + 0x0002_5003, + 0x000e_50b3, + 0x000f_b02f, + 0x0037_1241, + 0x0015_d0c5, + 0x0052_9377, + 0x001f_3025, + 0x0019_900d, + 0x0022_3133, + 0x0035_52d7, + 0x0018_516f, + 0x0014_b0a3, + 0x001b_10c1, + 0x0041_90d3, + 0x005a_d3fd, + 0x0035_f26b, + 0x0009_706d, + 0x0006_d005, + 0x0010_70a3, + 0x000c_700b, + 0x0006_7005, + 0x0059_9005, + 0x0003_d013, + 0x0008_9047, + 0x004c_d047, + 0x000a_d025, + 0x003d_71c9, + 0x000c_7049, + 0x002e_f0bf, + 0x0008_902b, + 0x002f_9025, + 0x0019_1053, + 0x0007_1035, + 0x001e_b017, + 0x0008_b061, + 0x001f_30a3, + 0x001a_f0d3, + 0x0001_d017, + 0x000b_500d, + 0x0001_d005, + 0x003c_7083, + 0x0013_d06d, + 0x001b_7095, + 0x0005_900d, + 0x0008_9049, + 0x001c_90df, + 0x0004_701f, + 0x001a_502b, + 0x001c_901d, + 0x0030_52ef, + 0x0010_d065, + 0x0002_f007, + 0x0013_9119, + 0x0013_30df, + 0x0015_d0df, + 0x003b_3397, + 0x0038_f0b5, + 0x001e_b15d, + 0x0010_d08b, + 0x001e_b09d, + 0x0006_1053, + 0x0018_50c7, + 0x0018_d0a3, + 0x0051_54cd, + 0x0001_100d, + 0x0033_d02b, + 0x0003_d025, + 0x001f_314b, + 0x002e_3017, + 0x0046_30bf, + 0x001a_3043, + 0x002a_b21d, + 0x0003_d01d, + 0x003a_d24b, + 0x000e_3025, + 0x0036_d10d, + 0x0010_1047, + 0x001b_715b, + 0x002a_1005, + 0x0042_7083, + 0x001f_d139, + 0x0028_70c5, + 0x001f_310d, + 0x0004_9025, + 0x002a_500d, + 0x0029_50b3, + 0x000e_908b, + 0x0011_b0ef, + 0x0028_d239, + 0x0048_b101, + 0x0011_b0b5, + 0x0017_f133, + 0x0013_3089, + 0x0006_100d, + 0x0013_d047, + 0x0034_7065, + 0x0015_d071, + 0x0017_b0ef, + 0x002f_9283, + 0x001a_3029, + 0x0005_3049, + 0x0011_b0ad, + 0x0028_d0b5, + 0x002b_3095, + 0x0008_3061, + 0x0020_b161, + 0x0012_5089, + 0x0025_10e3, + 0x0019_914b, + 0x001b_716f, + 0x001e_702b, + 0x002a_b25f, + 0x001a_5065, + 0x001c_1167, + 0x000d_306d, + 0x0024_b005, + 0x0008_b00d, + 0x001a_50ef, + 0x007e_b305, + 0x0035_f2dd, + 0x000e_90ad, + 0x001c_d025, + 0x0005_304f, + 0x0022_306d, + 0x0018_5025, + 0x001c_d10f, + 0x0019_904f, + 0x0007_f01d, + 0x0035_524b, + 0x0009_7095, + 0x000b_f08b, + 0x0006_100d, + 0x002c_5241, + 0x0025_f02b, + 0x0019_9071, + 0x0008_b065, + 0x001a_f065, + 0x0017_f065, + 0x003e_517b, + 0x0004_f03b, + 0x001d_30a3, + 0x0008_3071, + 0x0041_b025, + 0x0014_b10d, + 0x0022_d03d, + 0x0044_9397, + 0x0018_d065, + 0x002c_5029, + 0x0016_f101, + 0x0010_d097, + 0x0007_1053, + 0x0025_1049, + 0x0013_900d, + 0x000b_50b3, + 0x0007_104f, + 0x0009_d089, + 0x0031_3029, + 0x002a_5277, + 0x004a_3071, + 0x004a_3259, + 0x0006_1003, + 0x0041_93b3, + 0x0028_10bf, + 0x0034_713d, + 0x0055_1425, + 0x0041_b175, + 0x003b_33a9, + 0x0037_102b, + 0x0003_502b, + 0x006a_31af, + 0x000c_501d, + 0x0006_500b, + 0x0006_b059, + 0x0010_10e5, + 0x0023_90e9, + 0x0044_33d1, + 0x0023_310f, + 0x000a_d097, + 0x001c_d0e5, + 0x001a_5013, + 0x0008_303b, + 0x0011_b115, + 0x0010_70b5, + 0x001b_7107, + 0x0007_f00d, + 0x001b_118d, + 0x001b_7191, + 0x0040_70a3, + 0x0038_b065, + 0x0002_5017, + 0x001b_b029, + 0x002e_323b, + 0x001c_114b, + 0x001c_d10f, + 0x0013_903b, + 0x002f_910d, + 0x004a_9449, + 0x0013_9047, + 0x0016_7125, + 0x0010_f011, + 0x0035_f0a7, + 0x003a_d1a5, + 0x000c_10a3, + 0x0016_f06d, + 0x0022_30a7, + 0x002a_b107, + 0x001f_d1eb, + 0x002e_3089, + 0x0026_51fd, + 0x000d_3065, + 0x001c_9139, + 0x0042_701d, + 0x0030_5125, + 0x001c_d0c5, + 0x0004_3017, + 0x0004_7005, + 0x002e_7059, + 0x0026_b0b5, + 0x0011_b0e9, + 0x0005_300d, + 0x000a_d095, + 0x0026_b0bf, + 0x0026_91f7, + 0x0023_916f, + 0x0004_f011, + 0x0037_117f, + 0x0009_7065, + 0x0002_b00b, + 0x0004_302b, + 0x0010_d005, + 0x0035_f283, + 0x000b_501f, + 0x0010_7043, + 0x0025_90fb, + 0x0019_1151, + 0x008b_f125, + 0x000a_703d, + 0x000e_90d3, + 0x0026_5061, + 0x0037_7241, + 0x0004_3005, + 0x0035_b029, + 0x000e_f02f, + 0x000f_b013, + 0x0008_903b, + 0x0003_d029, + 0x0016_70c7, + 0x0009_7095, + 0x0029_509d, + 0x003d_f0ef, + 0x001d_31cd, + 0x001b_10f1, + 0x0011_b0ad, + 0x0029_507f, + 0x0000_d005, + 0x0017_b15b, + 0x0003_b01f, + 0x0013_910d, + 0x000a_3083, + 0x0067_f3fd, + 0x0025_111b, + 0x001f_71bb, + 0x0013_90bf, + 0x000b_f0b3, + 0x001a_f107, + 0x0040_f329, + 0x0049_d38b, + 0x000b_306d, + 0x0032_b2a5, + 0x0008_3017, + 0x003f_5013, + 0x001b_103b, + 0x001a_500d, + 0x003d_12a5, + 0x002a_5017, + 0x0017_f15d, + 0x000e_3065, + 0x0023_302f, + 0x001a_511b, + 0x002f_5059, + 0x0020_b011, + 0x0033_70d3, + 0x0004_9005, + 0x002c_f2c5, + 0x0084_135b, + 0x0005_903d, + 0x0016_101d, + 0x0019_1167, + 0x000a_709d, + 0x000a_d0a3, + 0x001c_d011, + 0x003a_d1d3, + 0x0013_7005, + 0x0013_d0f1, + 0x0013_703d, + 0x0015_b0e5, + 0x0017_506b, + 0x0009_500d, + 0x0002_b00b, + 0x0027_717b, + 0x0024_b09d, + 0x0002_f025, + 0x0019_9095, + 0x000b_507f, + 0x0025_f133, + 0x0001_1005, + 0x0014_b029, + 0x000a_d059, + 0x0049_3443, + 0x0023_901d, + 0x0010_d03b, + 0x001c_1175, + 0x0035_903d, + 0x0028_d257, + 0x0008_b01d, + 0x0013_7007, + 0x0013_9101, + 0x001c_10ad, + 0x0018_d025, + 0x0006_d029, + 0x0011_50bf, + 0x0002_b013, + 0x0037_3065, + 0x000c_701d, + 0x0024_107f, + 0x001a_5199, + 0x0046_906d, + 0x001b_10e9, + 0x0025_f21d, + 0x0017_b061, + 0x0017_f0a3, + 0x0013_d0fb, + 0x0009_5025, + 0x0011_503d, + 0x0012_509d, + 0x0015_b035, + 0x001b_103d, + 0x0024_b1b1, + 0x000c_5097, + 0x002a_5191, + 0x000b_5011, + 0x0008_b025, + 0x0018_50c1, + 0x0013_7125, + 0x0064_700d, + 0x0008_3017, + 0x002a_1007, + 0x001b_10c5, + 0x001b_1139, + 0x0011_5025, + 0x002e_31eb, + 0x0013_7005, + 0x0020_b1a5, + 0x000b_3089, + 0x0018_d15d, + 0x000e_f09d, + 0x000c_103b, + 0x0022_d01f, + 0x0037_306b, + 0x002d_707f, + 0x0005_300b, + 0x0012_5097, + 0x0006_7053, + 0x0026_b00b, + 0x000e_3043, + 0x000e_f005, + 0x0005_903d, + 0x0033_d0b3, + 0x0006_5043, + 0x0035_b0ef, + 0x0011_b0a3, + 0x0011_b035, + 0x003a_9139, + 0x001d_3005, + 0x001c_1047, + 0x0036_d22d, + 0x0023_30c7, + 0x000e_f06d, + 0x0010_7025, + 0x000f_106d, + 0x000e_f03d, + 0x000b_f089, + 0x001b_1115, + 0x0022_d119, + 0x002c_525f, + 0x0015_b139, + 0x0020_903d, + 0x0007_1067, + 0x0028_d18d, + 0x001a_5035, + 0x001f_3061, + 0x0023_b01d, + 0x0017_b0df, + 0x0040_f241, + 0x0008_9029, + 0x0013_310f, + 0x002f_9191, + 0x0027_7025, + 0x000b_302f, + 0x0015_111b, + 0x0023_b059, + 0x000b_5003, + 0x0021_d00d, + 0x003b_91f3, + 0x000e_90d3, + 0x0065_5151, + 0x000d_3059, + 0x001c_d0b5, + 0x000f_b09d, + 0x0011_5047, + 0x000b_303d, + 0x0024_1059, + 0x000f_b02f, + 0x0009_d08b, + 0x0022_3067, + 0x0005_3017, + 0x0010_f083, + 0x0046_30e3, + 0x002f_5107, + 0x0009_d03b, + 0x0015_b0e3, + 0x0015_101d, + 0x0017_f13d, + 0x0024_b0c5, + 0x0022_d049, + 0x001e_70e3, + 0x002a_115b, + 0x000e_500d, + 0x0046_932b, + 0x0012_5089, + 0x0009_5061, + 0x0006_d00d, + 0x001a_517b, + 0x0026_50a7, + 0x0005_9017, + 0x000f_10e3, + 0x001a_3049, + 0x0006_d005, + 0x0018_d02b, + 0x0013_3095, + 0x004a_3071, + 0x0017_b049, + 0x002c_51d3, + 0x004b_11c9, + 0x0005_3017, + 0x0028_7209, + 0x004b_12e3, + 0x001f_700d, + 0x0033_d0b5, + 0x0052_710f, + 0x0007_103b, + 0x003a_d223, + 0x001e_b18d, + 0x002e_7005, + 0x0013_308b, + 0x000e_9035, + 0x000d_3095, + 0x0024_b005, + 0x002d_d0a3, + 0x0027_70fb, + 0x000b_3013, + 0x000a_7053, + 0x0037_12d7, + 0x0013_901f, + 0x0006_5017, + 0x0006_5035, + 0x004b_d25f, + 0x000a_303d, + 0x0017_5095, + 0x001d_f0b5, + 0x002e_f1fd, + 0x000f_1025, + 0x0026_b24b, + 0x003f_528d, + 0x001e_71d3, + 0x0019_9035, + 0x0007_f00d, + 0x0032_90d3, + 0x0033_5223, + 0x0023_91c9, + 0x001d_f043, + 0x0011_50b5, + 0x000f_1059, + 0x0011_b10d, + 0x0013_7095, + 0x0009_504f, + 0x001a_f003, + 0x0011_b013, + 0x0010_d0e5, + 0x001c_f139, + 0x0015_d01d, + 0x000d_30a7, + 0x0031_d005, + 0x0011_500d, + 0x002c_5043, + 0x0008_3049, + 0x0025_f1f7, + 0x0038_b2cf, + 0x0009_704f, + 0x001a_f17b, + 0x0040_91fd, + 0x000a_301f, + 0x001d_f097, + 0x003f_517f, + 0x003d_7239, + 0x001b_1065, + 0x0026_51e7, + 0x0022_d1a5, + 0x002c_50e9, + 0x0005_9013, + 0x002e_3251, + 0x0011_5065, + 0x0006_700d, + 0x0011_b0e9, + 0x001d_f0a3, + 0x001c_f02f, + 0x0016_f02b, + 0x0015_102b, + 0x001d_31a5, + 0x0016_700d, + 0x0016_f107, + 0x0019_9059, + 0x0012_5025, + 0x0038_f1a3, + 0x001a_3139, + 0x0017_500d, + 0x0033_7305, + 0x0040_f3b3, + 0x0028_7005, + 0x0006_1035, + 0x0009_5025, + 0x002f_92a1, + 0x0009_d095, + 0x0009_7047, + 0x0065_b191, + 0x0001_1005, + 0x001a_f0f1, + 0x0001_f005, + 0x0041_91fd, + 0x0016_f095, + 0x001c_1035, + 0x003d_70b5, + 0x0013_700d, + 0x0025_71fd, + 0x002c_5199, + 0x000e_9059, + 0x0013_d059, + 0x0009_d03d, + 0x0025_116f, + 0x001b_7107, + 0x0008_9017, + 0x0010_10a7, + 0x001c_f071, + 0x0018_d059, + 0x0015_d09d, + 0x0040_91c9, + 0x0044_30fb, + 0x0045_5301, + 0x001c_1191, + 0x002f_506b, + 0x004c_70ef, + 0x0059_9265, + 0x0032_915b, + 0x0005_302f, + 0x0026_910f, + 0x0009_7029, + 0x0008_9025, + 0x0013_d067, + 0x0018_d0c5, + 0x0010_d029, + 0x0009_5067, + 0x001c_1067, + 0x0030_1233, + 0x001c_109d, + 0x0043_f107, + 0x000b_3005, + 0x002f_5025, + 0x000f_b0e5, + 0x005d_53d7, + 0x0024_b21d, + 0x0059_f3f5, + 0x0020_9035, + 0x0016_110f, + 0x001b_1011, + 0x0023_b0c5, + 0x0025_908b, + 0x0003_b005, + 0x0062_31af, + 0x002a_b139, + 0x003d_11c9, + 0x0004_903d, + 0x000a_d08b, + 0x0025_7191, + 0x003a_124b, + 0x002c_f0ef, + 0x001a_30a7, + 0x0019_10df, + 0x001a_f0e5, + 0x000f_10ef, + 0x0020_b005, + 0x001f_30ad, + 0x0015_1133, + 0x002a_5071, + 0x0025_1025, + 0x0025_7167, + 0x000a_303d, + 0x001b_b11b, + 0x005a_d00d, + 0x002e_f107, + 0x0022_31a5, + 0x0017_b089, + 0x0013_70c5, + 0x0007_f03b, + 0x0015_d10d, + 0x0033_d0ad, + 0x0013_d047, + 0x0011_9059, + 0x0019_904f, + 0x0018_d167, + 0x0012_500d, + 0x0003_500d, + 0x002f_9283, + 0x0006_5035, + 0x0015_d035, + 0x000b_5053, + 0x0013_7097, + 0x0023_b0e5, + 0x002a_b04f, + 0x0004_f049, + 0x0016_1059, + 0x000c_500d, + 0x0013_9083, + 0x000a_3071, + 0x0010_1043, + 0x0019_1017, + 0x001c_102b, + 0x0025_f1b7, + 0x002e_f25f, + 0x0017_f083, + 0x002e_309d, + 0x0011_b04f, + 0x0013_3029, + 0x0019_9061, + 0x0023_31e7, + 0x0010_10a3, + 0x001b_702f, + 0x0045_d0df, + 0x0006_d00b, + 0x002a_51e7, + 0x0004_f025, + 0x000d_3061, + 0x001f_d089, + 0x0031_d293, + 0x001a_313d, + 0x0006_1049, + 0x0011_903d, + 0x0012_5071, + 0x0038_b04f, + 0x0021_d0e9, + 0x0019_1025, + 0x001c_90d3, + 0x0003_d035, + 0x001a_303b, + 0x000f_1013, + 0x001a_f125, + 0x0013_30a7, + 0x0017_f0b5, + 0x000c_70c5, + 0x001a_f067, + 0x0009_d06b, + 0x0025_114b, + 0x0013_d0e5, + 0x0007_1005, + 0x0045_d13d, + 0x0010_d04f, + 0x0030_10a7, + 0x0017_5083, + 0x0033_703d, + 0x0005_9005, + 0x0007_f043, + 0x0023_9043, + 0x0007_1047, + 0x0007_103d, + 0x0025_f115, + 0x0006_d025, + 0x000e_501d, + 0x001f_70d3, + 0x000c_104f, + 0x001f_300d, + 0x001e_71b7, + 0x003d_1059, + 0x0026_b0ef, + 0x0019_9071, + 0x000b_30ad, + 0x0016_7005, + 0x0011_b00d, + 0x0006_703d, + 0x0031_d16f, + 0x0015_b01d, + 0x0015_d013, + 0x0012_5049, + 0x0025_f00b, + 0x001e_716f, + 0x0027_7053, + 0x0014_b02f, + 0x000a_d049, + 0x0015_b101, + 0x000e_9047, + 0x0055_1101, + 0x0027_706b, + 0x0008_301f, + 0x0023_314b, + 0x000c_1059, + 0x0002_9013, + 0x001a_517b, + 0x000e_50bf, + 0x002d_d1c1, + 0x000c_104f, + 0x0017_b061, + 0x0023_317b, + 0x001e_710f, + 0x006a_3083, + 0x0004_3017, + 0x0028_7209, + 0x003a_11eb, + 0x0017_b065, + 0x0008_9067, + 0x0058_f397, + 0x000d_f0bf, + 0x003a_d33b, + 0x002c_5191, + 0x0009_5053, + 0x002d_d025, + 0x000f_b035, + 0x001f_7089, + 0x0006_103d, + 0x000c_1047, + 0x0002_9011, + 0x000a_d061, + 0x001c_f1af, + 0x000c_109d, + 0x000c_101f, + 0x000c_5049, + 0x0026_9107, + 0x0025_903b, + 0x0023_914b, + 0x0002_b01d, + 0x000c_1083, + 0x0010_d0a7, + 0x002a_1101, + 0x0026_50a7, + 0x0027_715b, + 0x0024_11df, + 0x0017_f035, + 0x000e_9097, + 0x0004_f02b, + 0x0014_b10d, + 0x0031_d2c5, + 0x0013_d09d, + 0x002b_3161, + 0x0002_900b, + 0x0010_70b5, + 0x002f_9059, + 0x0013_90ef, + 0x000b_f06b, + 0x0025_11b7, + 0x0037_3025, + 0x005d_1107, + 0x001b_b1a3, + 0x0013_307f, + 0x001c_9185, + 0x0041_9407, + 0x001c_f0ad, + 0x003e_516f, + 0x0004_902b, + 0x0022_d0f1, + 0x0016_f107, + 0x0011_901f, + 0x000a_700d, + 0x0005_902f, + 0x002e_3175, + 0x002e_30f1, + 0x0025_715d, + 0x004f_f029, + 0x0010_f0ef, + 0x001f_306d, + 0x000c_50b3, + 0x0015_b005, + 0x0007_1065, + 0x0010_7101, + 0x0017_f167, + 0x001a_30b3, + 0x0018_d059, + 0x0018_d0ef, + 0x000d_3029, + 0x0037_32ab, + 0x001b_70e9, + 0x001c_f0df, + 0x001a_5029, + 0x000b_f04f, + 0x0010_708b, + 0x001a_30c5, + 0x0029_31f3, + 0x0031_d28d, + 0x0010_d00b, + 0x0004_702f, + 0x001b_7185, + 0x0028_d035, + 0x000e_9095, + 0x000e_5053, + 0x001d_f18d, + 0x0018_50ef, + 0x000f_1017, + 0x0017_5053, + 0x000c_7005, + 0x0037_11cf, + 0x0019_117f, + 0x0004_901f, + 0x0035_903b, + 0x0002_500d, + 0x0006_7029, + 0x0018_d067, + 0x0013_d115, + 0x0014_b00d, + 0x0028_1137, + 0x0011_b011, + 0x001d_f005, + 0x002c_f295, + 0x0028_d06d, + 0x0023_9223, + 0x0026_5007, + 0x001c_f089, + 0x001b_10ad, + 0x0028_324b, + 0x0006_d061, + 0x000e_f065, + 0x000b_3097, + 0x0028_701f, + 0x000b_3003, + 0x000b_306d, + 0x0013_d061, + 0x0025_7061, + 0x002e_31af, + 0x001e_7067, + 0x0024_108b, + 0x0011_b06b, + 0x001a_f067, + 0x000d_3013, + 0x000f_1017, + 0x0025_110d, + 0x0010_70a3, + 0x0014_b035, + 0x0007_1005, + 0x0017_510d, + 0x000f_1083, + 0x0004_9035, + 0x0022_d083, + 0x0016_7151, + 0x000d_3065, + 0x004f_f3c7, + 0x0023_b15d, + 0x001b_b115, + 0x000a_3061, + 0x0042_52b3, + 0x0006_b011, + 0x0014_b101, + 0x0031_303b, + 0x000e_9053, + 0x0010_10ad, + 0x0009_7007, + 0x001e_7089, + 0x0013_d0a7, + 0x0007_106b, + 0x0025_71df, + 0x0013_9005, + 0x0033_d2ef, + 0x002f_9025, + 0x0016_f0b5, + 0x0018_d17b, + 0x000e_90c1, + 0x0009_7025, + 0x0042_5347, + 0x003a_90c7, + 0x0035_b259, + 0x001a_f00d, + 0x001b_b199, + 0x0006_7017, + 0x0009_d02b, + 0x000e_500d, + 0x0020_b09d, + 0x000c_502b, + 0x000f_b065, + 0x0013_9065, + 0x001b_718d, + 0x0026_91a3, + 0x0009_d061, + 0x001c_1047, + 0x0001_7005, + 0x0018_d14b, + 0x0030_11c1, + 0x0015_b00b, + 0x0013_90b3, + 0x000b_5043, + 0x0006_502f, + 0x0010_7101, + 0x0010_d061, + 0x0016_7065, + 0x000f_106d, + 0x000e_5065, + 0x001c_9089, + 0x0043_f407, + 0x0003_b00d, + 0x0013_7035, + 0x0013_3013, + 0x002b_31b7, + 0x0004_3035, + 0x0008_3005, + 0x0010_d025, + 0x0008_3035, + 0x0011_b115, + 0x005f_3049, + 0x000e_302f, + 0x0015_b0bf, + 0x0023_3199, + 0x000e_9035, + 0x0040_911b, + 0x002a_1151, + 0x0006_d01d, + 0x0031_d239, + 0x0016_1119, + 0x000c_10ad, + 0x000d_f067, + 0x0006_5029, + 0x001c_1139, + 0x0006_700d, + 0x0005_9017, + 0x0041_b061, + 0x001a_5013, + 0x0016_f03d, + 0x001f_714b, + 0x002c_5139, + 0x0028_11c9, + 0x002e_30fb, + 0x0011_b035, + 0x0031_323b, + 0x0010_70e5, + 0x0005_301d, + 0x0030_10a3, + 0x000b_3047, + 0x0060_d1fd, + 0x001c_903d, + 0x0010_f047, + 0x0016_703b, + 0x0005_3029, + 0x000b_f06b, + 0x001d_303b, + 0x0014_b10d, + 0x0004_7043, + 0x004b_10c7, + 0x0015_d139, + 0x000f_107f, + 0x0023_902b, + 0x0019_903b, + 0x0011_b03d, + 0x001b_109d, + 0x003b_9089, + 0x0023_906b, + 0x0016_f107, + 0x004a_914b, + 0x0016_1097, + 0x000e_900d, + 0x001f_30ef, + 0x001f_d053, + 0x0011_90b3, + 0x001b_102b, + 0x0026_91d3, + 0x0008_b049, + 0x002a_520b, + 0x000c_1017, + 0x0030_5065, + 0x0009_5089, + 0x000f_b02f, + 0x0028_d0a3, + 0x0019_9089, + 0x0028_3059, + 0x0030_516f, + 0x0020_b01f, + 0x000f_b03b, + 0x0017_5067, + 0x002e_31cd, + 0x000a_3043, + 0x002e_f241, + 0x000a_70a3, + 0x0032_b301, + 0x0036_d17f, + 0x0013_30ad, + 0x003a_12ef, + 0x0008_b06d, + 0x001c_d0c1, + 0x0013_3049, + 0x0028_d133, + 0x0013_3029, + 0x0013_d00d, + 0x0023_b0e3, + 0x0011_509d, + 0x002c_f065, + 0x001d_30b3, + 0x0006_d00b, + 0x005a_d3b9, + 0x0015_d107, + 0x000c_7005, + 0x001f_31a3, + 0x0011_b115, + 0x0024_11c1, + 0x000f_10c5, + 0x0033_d049, + 0x0028_311b, + 0x0027_71cd, + 0x0003_d03b, + 0x0022_d09d, + 0x0013_9025, + 0x0017_50e9, + 0x0031_d0c1, + 0x0019_9089, + 0x0008_b025, + 0x0006_d025, + 0x0032_9259, + 0x002a_10c7, + 0x000c_1097, + 0x002a_11cf, + 0x0010_f00b, + 0x002a_110f, + 0x002e_317f, + 0x003c_b35b, + 0x0059_30df, + 0x0059_935b, + 0x0020_b047, + 0x0021_d133, + 0x0002_9011, + 0x001a_f139, + 0x0035_50df, + 0x0009_7043, + 0x0022_d223, + 0x0029_315b, + 0x0024_b007, + 0x0020_9003, + 0x0015_d017, + 0x0011_506d, + 0x000d_f047, + 0x003a_91bb, + 0x0021_d133, + 0x0026_9025, + 0x0025_70e3, + 0x0023_91cf, + 0x0018_d00d, + 0x0013_7005, + 0x0006_b047, + 0x0010_10ef, + 0x0015_106d, + 0x0023_3035, + 0x0036_d1c1, + 0x000b_3005, + 0x002e_7199, + 0x003a_d043, + 0x001b_70b3, + 0x002c_503b, + 0x0065_54c7, + 0x0010_d04f, + 0x001f_3199, + 0x000f_1071, + 0x0015_d00d, + 0x0033_b0a7, + 0x0025_f1c9, + 0x0028_11b7, + 0x0019_1049, + 0x000a_7053, + 0x001c_1053, + 0x002f_9029, + 0x000e_3067, + 0x0014_b029, + 0x003f_10c1, + 0x0028_3277, + 0x001f_71bb, + 0x0017_501f, + 0x0007_f071, + 0x0010_7013, + 0x0024_11bb, + 0x0015_d151, + 0x0025_906d, + 0x002c_50c1, + 0x002e_f295, + 0x001c_102b, + 0x0015_1067, + 0x0033_b13d, + 0x0006_b04f, + 0x001f_31c1, + 0x0025_f151, + 0x0032_b265, + 0x0028_1139, + 0x0010_d0e3, + 0x0014_b0f1, + 0x0020_b0b5, + 0x0004_301d, + 0x0050_b469, + 0x0018_5089, + 0x0003_5003, + 0x0004_7017, + 0x0008_906d, + 0x0025_f1b7, + 0x003f_b043, + 0x0010_f0b3, + 0x0011_500d, + 0x000b_f0a7, + 0x0020_b1d3, + 0x0011_5029, + 0x0012_50e3, + 0x003b_30e9, + 0x0006_1011, + 0x005b_3185, + 0x000d_f00d, + 0x000d_3043, + 0x0004_303b, + 0x002e_309d, + 0x003c_b283, + 0x0013_3035, + 0x001a_50c5, + 0x001b_7025, + 0x000a_3071, + 0x002d_7061, + 0x0044_31b7, + 0x0015_1005, + 0x0039_710f, + 0x0011_b0a3, + 0x0034_733b, + 0x0055_73fd, + 0x004d_5371, + 0x0008_900d, + 0x0006_b043, + 0x005b_f33b, + 0x0026_5175, + 0x001b_b125, + 0x000c_7005, + 0x0019_914b, + 0x0023_3191, + 0x0026_9119, + 0x0007_f059, + 0x000a_d06d, + 0x002d_d067, + 0x001d_f137, + 0x001b_10bf, + 0x001d_f11b, + 0x002a_1095, + 0x0011_901d, + 0x000f_10a3, + 0x005c_f017, + 0x0012_5007, + 0x001c_d013, + 0x0009_d011, + 0x0023_b1a5, + 0x0008_9067, + 0x001b_100d, + 0x000c_502f, + 0x003f_b2a5, + 0x0015_10f1, + 0x0043_f0b5, + 0x0049_3455, + 0x0016_1035, + 0x0003_502b, + 0x0008_b07f, + 0x0016_f00d, + 0x002b_d0b3, + 0x0009_d061, + 0x001c_11b7, + 0x0025_7161, + 0x0025_71bb, + 0x001a_515d, + 0x0004_9017, + 0x0030_50c7, + 0x0011_9083, + 0x0042_d0a3, + 0x002e_f281, + 0x0013_9095, + 0x0013_70df, + 0x002d_d00d, + 0x0010_104f, + 0x0013_9097, + 0x0023_b1c9, + 0x000c_7005, + 0x000e_30b5, + 0x001a_f00d, + 0x0010_10e5, + 0x0018_5133, + 0x000e_f0bf, + 0x0014_b097, + 0x0029_502b, + 0x0009_706b, + 0x0038_b22d, + 0x0009_700d, + 0x0028_726b, + 0x002f_517f, + 0x0042_524b, + 0x000b_3043, + 0x0023_90e9, + 0x000d_302f, + 0x0010_f071, + 0x0008_903d, + 0x002e_f133, + 0x0022_d01f, + 0x002b_d259, + 0x0032_b281, + 0x0033_d005, + 0x0060_72bd, + 0x0019_9119, + 0x001f_d119, + 0x003a_110d, + 0x001c_1043, + 0x0006_503b, + 0x0016_7035, + 0x0003_d035, + 0x001c_f16f, + 0x000a_d089, + 0x0026_9233, + 0x0028_7061, + 0x000d_3005, + 0x001e_7107, + 0x002a_503b, + 0x0001_d00b, + 0x0006_501d, + 0x0009_d043, + 0x0028_117b, + 0x0008_b07f, + 0x0003_d01f, + 0x0029_30a7, + 0x0010_f0c7, + 0x001c_916f, + 0x0006_d01f, + 0x0018_d151, + 0x0015_d0bf, + 0x0010_7049, + 0x0004_f005, + 0x0028_d1b7, + 0x0032_90e5, + 0x002f_9277, + 0x000b_5047, + 0x001d_f0e9, + 0x0007_1005, + 0x0050_b1a5, + 0x0034_72f5, + 0x0004_903d, + 0x001d_302f, + 0x0017_5137, + 0x002f_906b, + 0x000f_b07f, + 0x001f_d043, + 0x0072_76f7, + 0x0017_b06b, + 0x002e_7257, + 0x0021_d0e5, + 0x0018_d04f, + 0x000a_301d, + 0x002d_d209, + 0x000e_508b, + 0x0017_f14b, + 0x0015_d115, + 0x0023_9071, + 0x0028_71b7, + 0x0020_b0b5, + 0x0017_f0bf, + 0x001f_d0e5, + 0x0065_510d, + 0x001f_d0e3, + 0x004f_f4a3, + 0x0023_90ef, + 0x0036_d1c1, + 0x0021_d0c5, + 0x001c_10e3, + 0x0004_701f, + 0x0031_d1af, + 0x0051_b161, + 0x002a_5119, + 0x000a_7089, + 0x002a_10d3, + 0x0004_301d, + 0x0026_91c9, + 0x0004_7035, + 0x0037_10b3, + 0x0027_71af, + 0x0005_900d, + 0x000a_3061, + 0x0048_b47f, + 0x001f_31b1, + 0x0018_d03b, + 0x0031_d011, + 0x0017_b017, + 0x0078_b337, + 0x001b_b00d, + 0x001d_f133, + 0x0017_b06b, + 0x003d_1011, + 0x0030_1191, + 0x0009_d097, + 0x0009_d071, + 0x001b_b175, + 0x001c_d03d, + 0x001c_907f, + 0x0019_1025, + 0x0025_716f, + 0x0023_903b, + 0x0059_5007, + 0x0017_b0c7, + 0x004c_d0bf, + 0x0024_1071, + 0x002e_f1f7, + 0x0022_d0a7, + 0x0008_3043, + 0x0060_738b, + 0x000b_3025, + 0x001f_3097, + 0x0020_91a5, + 0x0026_b251, + 0x000c_701d, + 0x0037_714b, + 0x000e_503b, + 0x0008_b07f, + 0x0008_3035, + 0x000b_3011, + 0x001a_f0df, + 0x0010_70c7, + 0x0029_517f, + 0x0030_5005, + 0x0011_900d, + 0x0044_9337, + 0x003d_702b, + 0x0008_9025, + 0x000d_3043, + 0x0024_b1c9, + 0x0033_b00d, + 0x0013_d06b, + 0x000a_d09d, + 0x002f_901d, + 0x0040_93ad, + 0x0013_9095, + 0x001d_3059, + 0x0017_f10d, + 0x0006_700d, + 0x000a_3061, + 0x0020_b133, + 0x000e_5089, + 0x004e_b1e7, + 0x0007_f035, + 0x001f_31df, + 0x0015_b0e3, + 0x0015_d0a3, + 0x001f_30c1, + 0x000d_3097, + 0x0017_f00b, + 0x001a_3101, + 0x0018_d043, + 0x002a_503d, + 0x004f_d101, + 0x0021_d0e9, + 0x0020_b0f1, + 0x0016_7115, + 0x002d_7067, + 0x0016_10e5, + 0x001f_d1c1, + 0x0036_d241, + 0x0015_b0ef, + 0x0014_b005, + 0x0017_b005, + 0x001f_d15d, + 0x0045_d005, + 0x002a_b15b, + 0x000b_f059, + 0x001f_30fb, + 0x001c_d1b1, + 0x000c_104f, + 0x0029_303b, + 0x000b_3067, + 0x0010_103d, + 0x0051_50a3, + 0x0025_71eb, + 0x000a_3095, + 0x000a_3035, + 0x0018_d133, + 0x000d_f067, + 0x0013_d0bf, + 0x0025_10ad, + 0x001b_b161, + 0x001b_709d, + 0x001a_f00d, + 0x001d_3013, + 0x004a_92dd, + 0x000d_f0a7, + 0x000e_90a3, + 0x0035_90fb, + 0x0033_71eb, + 0x002a_11b7, + 0x000f_108b, + 0x003b_310f, + 0x0037_7167, + 0x0027_7167, + 0x0007_f005, + 0x003a_102f, + 0x001d_f10d, + 0x0005_904f, + 0x0002_5013, + 0x0017_5167, + 0x0019_118d, + 0x003a_115b, + 0x0035_9239, + 0x000c_704f, + 0x000f_b02f, + 0x0019_1151, + 0x000a_308b, + 0x0044_30ad, + 0x0018_5115, + 0x0009_508b, + 0x0034_72dd, + 0x0017_f15b, + 0x0010_f047, + 0x000e_500d, + 0x0038_f1cf, + 0x000a_3011, + 0x0016_10b5, + 0x0027_710d, + 0x0014_b03d, + 0x0025_7003, + 0x0016_700b, + 0x000b_f0ad, + 0x0032_9209, + 0x0032_91a3, + 0x0020_9191, + 0x001a_503b, + 0x0015_1047, + 0x0005_303d, + 0x000e_5071, + 0x0016_102b, + 0x000b_5067, + 0x004a_9107, + 0x001b_116f, + 0x0017_5025, + 0x0008_9005, + 0x0025_710d, + 0x0065_343f, + 0x003f_11a5, + 0x0032_9133, + 0x0023_b119, + 0x001b_101d, + 0x001c_d065, + 0x000a_7067, + 0x0018_5151, + 0x001b_1065, + 0x0027_717b, + 0x0021_d139, + 0x003d_733b, + 0x0023_902f, + 0x0028_717b, + 0x001a_f0fb, + 0x0003_b007, + 0x001c_1191, + 0x000a_d01f, + 0x0025_7239, + 0x003e_52cf, + 0x004a_92a1, + 0x001b_b137, + 0x003a_11cd, + 0x0006_d017, + 0x000e_9005, + 0x001a_3139, + 0x0002_5013, + 0x0006_b059, + 0x0002_5017, + 0x001c_915b, + 0x0010_d097, + 0x001a_f0a7, + 0x000f_103b, + 0x0052_724b, + 0x0038_f241, + 0x0022_d10f, + 0x002e_701d, + 0x0011_50c7, + 0x007e_b0ad, + 0x000e_50a3, + 0x000e_5089, + 0x0006_5047, + 0x001c_f065, + 0x0010_d059, + 0x001c_f14b, + 0x0016_f0e3, + 0x0007_1053, + 0x0024_b1bb, + 0x0010_d0e5, + 0x0023_b00d, + 0x0006_b005, + 0x0017_50b5, + 0x002f_9293, + 0x000f_b06d, + 0x000c_7029, + 0x0026_b059, + 0x000f_10df, + 0x000c_5089, + 0x0010_7049, + 0x001d_300b, + 0x0017_b137, + 0x0014_b035, + 0x0006_5059, + 0x002a_5251, + 0x0024_11c1, + 0x001d_f115, + 0x0005_3005, + 0x0028_1233, + 0x000b_f043, + 0x001f_7013, + 0x0033_52a1, + 0x001a_301d, + 0x0028_1083, + 0x002e_7241, + 0x0022_315b, + 0x0027_7013, + 0x0007_f067, + 0x0024_b241, + 0x0005_3025, + 0x000c_5059, + 0x0000_d005, + 0x0016_1065, + 0x0028_7257, + 0x0000_b007, + 0x0021_d1bb, + 0x0008_3035, + 0x0010_100b, + 0x0009_d097, + 0x001b_b0ad, + 0x0024_b005, + 0x0051_101d, + 0x001f_d175, + 0x0020_b011, + 0x001c_90ef, + 0x002a_523b, + 0x0003_d025, + 0x002f_5049, + 0x0023_b1b7, + 0x001c_90c7, + 0x0019_10e5, + 0x003b_9083, + 0x002a_1043, + 0x000e_90c7, + 0x0009_7043, + 0x001a_315b, + 0x008f_55c9, + 0x0025_70b3, + 0x0011_b03b, + 0x0013_70a3, + 0x0039_7137, + 0x000d_f0a3, + 0x0001_d00d, + 0x0022_3053, + 0x000e_9061, + 0x0011_90a7, + 0x0008_302b, + 0x0036_d329, + 0x0006_b01f, + 0x002a_101f, + 0x001e_b0a3, + 0x0002_501f, + 0x003d_1005, + 0x0016_f035, + 0x000c_5025, + 0x0026_9125, + 0x0002_5005, + 0x0007_1067, + 0x0025_1239, + 0x005f_3005, + 0x002a_522d, + 0x001b_1049, + 0x001f_71c9, + 0x003f_b137, + 0x002d_d16f, + 0x0006_7061, + 0x0011_50b5, + 0x000a_306b, + 0x0014_b00d, + 0x0009_701f, + 0x0025_9185, + 0x0032_9013, + 0x005a_d035, + 0x0033_5025, + 0x0010_d03d, + 0x002e_f115, + 0x0039_70e3, + 0x000f_1013, + 0x003b_336d, + 0x0064_162f, + 0x0015_d0b5, + 0x0037_3359, + 0x001b_7029, + 0x000d_3067, + 0x0016_f10d, + 0x001b_10b5, + 0x0008_903b, + 0x000c_104f, + 0x0029_300d, + 0x0015_b035, + 0x0046_3281, + 0x0016_f08b, + 0x0010_70d3, + 0x003e_5133, + 0x002d_d20b, + 0x001a_302f, + 0x001e_70df, + 0x0006_700b, + 0x007b_b04f, + 0x0020_918d, + 0x0019_10b5, + 0x003d_72dd, + 0x004f_d35f, + 0x001b_b137, + 0x0025_7241, + 0x000a_d049, + 0x0016_110d, + 0x0015_d115, + 0x001c_d02f, + 0x0015_b0e9, + 0x0016_708b, + 0x0014_b04f, + 0x001b_10d3, + 0x001b_b16f, + 0x000e_f0b5, + 0x0023_b09d, + 0x0040_73b9, + 0x001f_d10d, + 0x0035_b335, + 0x0028_7233, + 0x0012_5035, + 0x004c_f053, + 0x0022_d01f, + 0x000e_9061, + 0x001d_f005, + 0x0011_900b, + 0x0040_7013, + 0x000d_f06b, + 0x0031_308b, + 0x0010_10f1, + 0x0018_d0e5, + 0x0022_302f, + 0x0043_f42d, + 0x0019_100b, + 0x000c_503b, + 0x0023_9133, + 0x0010_701f, + 0x0029_322d, + 0x000c_1059, + 0x004b_1313, + 0x0011_50d3, + 0x000d_3083, + 0x001b_710f, + 0x000c_507f, + 0x0013_3125, + 0x0004_f029, + 0x0015_b101, + 0x0013_30e5, + 0x000f_10e9, + 0x0002_f01d, + 0x002d_702b, + 0x0015_1007, + 0x0037_1003, + 0x0028_d265, + 0x0023_b0df, + 0x000c_5029, + 0x0022_d059, + 0x0031_3293, + 0x0003_d03b, + 0x0020_9119, + 0x000d_f013, + 0x0023_9065, + 0x0026_b265, + 0x002c_f251, + 0x001c_d15b, + 0x002b_d223, + 0x003f_5137, + 0x0037_322d, + 0x0028_7185, + 0x0035_f0df, + 0x000d_f053, + 0x001f_3025, + 0x0006_b025, + 0x0004_7043, + 0x001b_717b, + 0x002c_5259, + 0x0032_92f5, + 0x0016_710d, + 0x002b_30e5, + 0x001e_714b, + 0x0012_5061, + 0x000c_502f, + 0x002b_d071, + 0x0018_d043, + 0x002c_5233, + 0x001a_f0bf, + 0x004a_3119, + 0x0015_b083, + 0x0008_901f, + 0x0033_703b, + 0x0024_b061, + 0x0045_d003, + 0x0011_b03b, + 0x001a_30fb, + 0x0008_9035, + 0x0029_507f, + 0x0023_3089, + 0x001c_9185, + 0x000a_d067, + 0x0020_90e3, + 0x0013_d0ef, + 0x0026_5139, + 0x002a_1233, + 0x0022_d191, + 0x000f_b04f, + 0x0035_f1bb, + 0x001a_f09d, + 0x001a_f0b5, + 0x001c_91b7, + 0x001a_50c7, + 0x002b_310d, + 0x000e_906d, + 0x0030_521d, + 0x0038_f32b, + 0x0004_f02b, + 0x0008_b01f, + 0x002b_316f, + 0x0024_b125, + 0x0020_90f1, + 0x0018_d10d, + 0x002d_717b, + 0x000e_906d, + 0x000b_3005, + 0x0030_51eb, + 0x0018_5061, + 0x0036_d0d3, + 0x0013_3025, + 0x001d_f0d3, + 0x0017_f0b5, + 0x000f_b02b, + 0x0019_1035, + 0x0016_1083, + 0x0025_713d, + 0x0015_10ef, + 0x0001_300d, + 0x0013_30b3, + 0x000e_50bf, + 0x0023_b22d, + 0x000e_304f, + 0x000a_708b, + 0x0043_f33b, + 0x0007_f071, + 0x003a_1251, + 0x001b_1133, + 0x0028_111b, + 0x0018_d107, + 0x0015_d043, + 0x0025_11cf, + 0x0026_5191, + 0x0033_517f, + 0x003d_f0b3, + 0x0016_115b, + 0x0029_30c7, + 0x0011_b005, + 0x0011_908b, + 0x0012_50e9, + 0x000e_9053, + 0x0025_f00b, + 0x0034_71cf, + 0x0018_d071, + 0x0003_501d, + 0x0021_d0a7, + 0x0012_5095, + 0x0016_f0c1, + 0x0006_5005, + 0x001a_317b, + 0x0017_50df, + 0x002a_1035, + 0x002a_b06d, + 0x0007_1013, + 0x0017_f15b, + 0x0010_1029, + 0x0030_5115, + 0x0015_b0c5, + 0x000c_70b3, + 0x0018_50f1, + 0x0017_b0e9, + 0x0024_10fb, + 0x003b_903d, + 0x0004_f049, + 0x0011_503d, + 0x000e_300d, + 0x0047_f199, + 0x0016_f01d, + 0x0002_9007, + 0x0006_d013, + 0x0006_104f, + 0x0037_706b, + 0x001c_f185, + 0x001a_310d, + 0x002a_1125, + 0x0018_d007, + 0x0005_3025, + 0x000a_701d, + 0x0018_d083, + 0x001a_30f1, + 0x000b_503d, + 0x0029_310d, + 0x002c_f0b3, + 0x0002_901d, + 0x0011_9005, + 0x0008_3049, + 0x0005_9029, + 0x0034_7119, + 0x0013_3071, + 0x0007_1043, + 0x0033_d00b, + 0x0015_b09d, + 0x0006_b00d, + 0x002a_1265, + 0x000e_50a7, + 0x0020_907f, + 0x000e_5013, + 0x0020_b0df, + 0x003d_f1f3, + 0x0013_9137, + 0x0028_702b, + 0x0011_9053, + 0x0037_3329, + 0x0013_3083, + 0x001c_f167, + 0x0025_100d, + 0x003e_53b3, + 0x0031_31cf, + 0x0011_9101, + 0x002d_d281, + 0x002d_71d3, + 0x0008_9061, + 0x0016_10a7, + 0x001a_f0ad, + 0x0006_1005, + 0x0010_7025, + 0x002d_7185, + 0x0009_7089, + 0x001c_10d3, + 0x002b_d233, + 0x0050_b1b7, + 0x003a_d265, + 0x0020_91df, + 0x0018_517f, + 0x000f_b0ef, + 0x0004_9005, + 0x000e_f007, + 0x0016_f08b, + 0x0033_5065, + 0x0011_50a7, + 0x0033_b049, + 0x0009_d013, + 0x0044_93fd, + 0x0028_d005, + 0x0023_b09d, + 0x003b_91d3, + 0x0013_d0c5, + 0x0009_501d, + 0x000e_f01f, + 0x0023_b03d, + 0x0015_b115, + 0x005c_924b, + 0x000a_7083, + 0x001c_f199, + 0x0010_7025, + 0x0042_d305, + 0x000b_3059, + 0x000f_10c7, + 0x0022_310f, + 0x0016_1151, + 0x001e_711b, + 0x0013_d00b, + 0x000e_3043, + 0x000f_b08b, + 0x003b_31c9, + 0x0051_b40f, + 0x0019_911b, + 0x0015_d095, + 0x000d_3029, + 0x000a_d03b, + 0x0029_315b, + 0x0025_1209, + 0x0016_70ef, + 0x000c_506b, + 0x0003_b005, + 0x0025_70bf, + 0x0013_d089, + 0x003f_d14b, + 0x0048_140f, + 0x0017_50e5, + 0x002a_5097, + 0x002a_51cf, + 0x0022_303d, + 0x0018_5125, + 0x0025_f251, + 0x0029_31e7, + 0x0046_93d7, + 0x0028_7223, + 0x0011_501d, + 0x001b_10e9, + 0x001b_7005, + 0x0013_9097, + 0x003b_306b, + 0x000c_103d, + 0x000b_50a3, + 0x0025_9167, + 0x0015_1071, + 0x0013_d0b3, + 0x001b_b043, + 0x001f_315d, + 0x0008_b00d, + 0x000d_f0b3, + 0x001b_b0b3, + 0x0020_90d3, + 0x0037_71cf, + 0x0015_1025, + 0x0011_90c5, + 0x0015_d115, + 0x000c_5061, + 0x0037_7161, + 0x0014_b067, + 0x0021_d08b, + 0x0023_b17f, + 0x0023_9035, + 0x003c_707f, + 0x0063_d23b, + 0x0020_b0bf, + 0x0035_50e5, + 0x0007_f00d, + 0x0029_3251, + 0x0013_306d, + 0x0042_d3b3, + 0x0030_1061, + 0x0016_f0e9, + 0x0024_115d, + 0x0017_5101, + 0x001e_70ad, + 0x000c_70b5, + 0x0003_b005, + 0x000e_f097, + 0x0017_510f, + 0x001d_30e9, + 0x0004_f03d, + 0x000e_908b, + 0x000e_3059, + 0x0015_1137, + 0x001f_d08b, + 0x001f_31b1, + 0x004a_903d, + 0x004b_1107, + 0x003c_72bd, + 0x002e_711b, + 0x000b_5025, + 0x001b_7125, + 0x0012_504f, + 0x000b_307f, + 0x000b_f03b, + 0x0008_3065, + 0x0011_90e5, + 0x000a_d0a3, + 0x001a_f0e3, + 0x0041_916f, + 0x0014_b01f, + 0x0010_f067, + 0x0007_1065, + 0x0006_5035, + 0x0035_b011, + 0x002a_b139, + 0x000e_906b, + 0x0049_d269, + 0x0031_d17b, + 0x0025_700d, + 0x004d_54cf, + 0x0028_3047, + 0x001d_f107, + 0x001b_11a3, + 0x0019_9097, + 0x0035_90ad, + 0x0027_7137, + 0x0008_b06b, + 0x0037_1233, + 0x0026_5241, + 0x0013_709d, + 0x001c_f119, + 0x003d_f025, + 0x001e_b1c9, + 0x001c_10a7, + 0x001b_7029, + 0x000e_5065, + 0x0008_3007, + 0x0020_b059, + 0x0012_510f, + 0x0015_d02f, + 0x0038_f095, + 0x0030_5151, + 0x0006_5005, + 0x0022_d06b, + 0x000c_501f, + 0x0013_d017, + 0x001a_5007, + 0x004c_13cb, + 0x0018_500d, + 0x0025_f00b, + 0x001e_b1af, + 0x0035_b28d, + 0x001f_d03d, + 0x0005_3013, + 0x0029_5199, + 0x000a_300b, + 0x0013_303b, + 0x000d_f017, + 0x0011_502f, + 0x0042_d2bd, + 0x0011_910d, + 0x003d_136d, + 0x0016_1137, + 0x0020_9071, + 0x0020_b161, + 0x001d_3029, + 0x0012_510d, + 0x0020_907f, + 0x003b_33a9, + 0x002e_30c5, + 0x0032_926b, + 0x0056_5241, + 0x000c_500d, + 0x000b_3067, + 0x002e_700b, + 0x000e_30ad, + 0x0009_708b, + 0x0002_900d, + 0x000b_508b, + 0x002a_508b, + 0x003c_b283, + 0x002e_7251, + 0x0020_b0c1, + 0x0037_128d, + 0x0012_50fb, + 0x000f_b029, + 0x0015_b00d, + 0x0017_f071, + 0x001c_1133, + 0x0013_301f, + 0x0002_b025, + 0x0018_d067, + 0x000d_304f, + 0x0010_f10d, + 0x0003_d005, + 0x0023_30e5, + 0x0022_3161, + 0x000c_1003, + 0x0025_7025, + 0x0019_902f, + 0x000a_300b, + 0x0010_10b3, + 0x000d_f005, + 0x0013_900b, + 0x0011_5083, + 0x0032_b11b, + 0x0012_502f, + 0x003f_1071, + 0x001c_117f, + 0x0026_b107, + 0x0000_d003, + 0x0035_924b, + 0x0019_102b, + 0x0029_51f3, + 0x003c_7199, + 0x0029_51e7, + 0x0015_d15b, + 0x000b_f02f, + 0x0033_b257, + 0x0006_b00d, + 0x0008_9047, + 0x000e_30a3, + 0x0022_d02b, + 0x0032_922d, + 0x0018_5115, + 0x001c_1007, + 0x0008_3013, + 0x002b_d26b, + 0x001e_710d, + 0x0011_b07f, + 0x0004_301d, + 0x000b_f047, + 0x0003_b01d, + 0x0011_50b3, + 0x0028_325f, + 0x0020_b101, + 0x0026_9035, + 0x0011_906d, + 0x0023_30b5, + 0x003f_53c7, + 0x000a_d005, + 0x001e_b02f, + 0x0024_b1f7, + 0x000e_9061, + 0x0033_51b7, + 0x0014_b0e3, + 0x000e_308b, + 0x0013_302f, + 0x0010_7013, + 0x0015_d01f, + 0x0020_902b, + 0x000f_1059, + 0x0011_b0a3, + 0x0009_d04f, + 0x000e_f0d3, + 0x0009_5059, + 0x002b_d1c9, + 0x001c_f0d3, + 0x0001_f011, + 0x0020_91b1, + 0x0024_103d, + 0x001b_70c7, + 0x0016_1061, + 0x001a_3049, + 0x000c_5053, + 0x003f_1313, + 0x001c_f13d, + 0x0015_d01d, + 0x0035_b02b, + 0x0008_300d, + 0x002f_9175, + 0x0007_1053, + 0x0018_5065, + 0x0033_72e7, + 0x000a_7053, + 0x002a_10c5, + 0x0020_b067, + 0x001e_b053, + 0x000f_b00d, + 0x0017_b0fb, + 0x0020_9115, + 0x0040_9083, + 0x002f_521d, + 0x000b_508b, + 0x000f_b095, + 0x0022_3125, + 0x0034_7191, + 0x000e_9029, + 0x0010_103d, + 0x000f_b053, + 0x0037_1329, + 0x0031_d00b, + 0x0033_b22d, + 0x001b_1161, + 0x0008_904f, + 0x000e_f049, + 0x0037_3335, + 0x0028_11fd, + 0x002e_317b, + 0x0012_5115, + 0x001e_706b, + 0x0015_10a7, + 0x002f_5259, + 0x000e_5059, + 0x0041_b007, + 0x0009_700d, + 0x0006_702b, + 0x0016_707f, + 0x003a_d10f, + 0x0021_d061, + 0x0006_500d, + 0x000f_1097, + 0x0008_3053, + 0x0013_902b, + 0x0044_52bd, + 0x0029_51f3, + 0x0022_d059, + 0x000d_f0c1, + 0x0008_9011, + 0x0019_900d, + 0x0024_b02b, + 0x000c_502f, + 0x001b_71af, + 0x0018_d01f, + 0x0061_f00b, + 0x0008_b029, + 0x001d_f1bb, + 0x0009_500b, + 0x001c_90e9, + 0x0018_d0d3, + 0x0017_f175, + 0x000d_30c1, + 0x001e_700d, + 0x0031_31c1, + 0x0004_303d, + 0x0010_f005, + 0x0021_d071, + 0x0013_7097, + 0x000d_303b, + 0x0003_d01f, + 0x0019_10e9, + 0x0018_d0fb, + 0x0023_91bb, + 0x000b_5005, + 0x000e_f061, + 0x001b_1065, + 0x0030_101f, + 0x001d_f11b, + 0x0017_b00d, + 0x004b_1199, + 0x0028_3115, + 0x0024_11a5, + 0x0028_d0a7, + 0x0030_51b7, + 0x000b_500d, + 0x0038_b01d, + 0x001e_700b, + 0x0042_d1f3, + 0x0010_706d, + 0x000e_9059, + 0x0008_b00d, + 0x0032_9295, + 0x000b_509d, + 0x0013_90e3, + 0x0004_f005, + 0x0006_d00d, + 0x0032_908b, + 0x0005_3011, + 0x0015_d035, + 0x001a_517f, + 0x0020_b097, + 0x000c_5025, + 0x0028_d003, + 0x0002_900b, + 0x0018_5119, + 0x001b_b06b, + 0x000b_5053, + 0x0022_306b, + 0x0037_30bf, + 0x005c_f42d, + 0x0030_1175, + 0x001f_d15b, + 0x0033_7025, + 0x0026_510d, + 0x0016_7089, + 0x0031_d28d, + 0x004a_32a5, + 0x0023_3133, + 0x0045_d265, + 0x0007_1053, + 0x0013_7049, + 0x001c_115b, + 0x000c_503d, + 0x0015_d0e9, + 0x0013_d0e9, + 0x0004_9011, + 0x0025_90e3, + 0x000e_9035, + 0x0040_9013, + 0x000d_304f, + 0x001a_304f, + 0x0039_731d, + 0x0025_7067, + 0x0005_3047, + 0x003f_13cb, + 0x0062_32f9, + 0x001b_b025, + 0x0016_10a3, + 0x0006_d00d, + 0x0025_91df, + 0x0004_3005, + 0x0029_5071, + 0x0007_f01d, + 0x0019_9049, + 0x003a_d15b, + 0x000e_3013, + 0x001c_f005, + 0x000f_1005, + 0x0015_b053, + 0x0013_d11b, + 0x0001_f00d, + 0x0008_b029, + 0x0020_b025, + 0x001e_b095, + 0x0013_d025, + 0x0023_91cd, + 0x0045_5371, + 0x003b_903d, + 0x0008_b067, + 0x0004_7043, + 0x0017_50f1, + 0x000e_308b, + 0x0032_b2c5, + 0x000c_1059, + 0x001d_f071, + 0x0050_91cd, + 0x0009_502b, + 0x0002_9025, + 0x000f_100b, + 0x0013_d10d, + 0x001c_90a3, + 0x0020_900d, + 0x000d_303b, + 0x0019_90fb, + 0x0011_b01f, + 0x0004_f049, + 0x000e_9095, + 0x0037_1049, + 0x0013_30d3, + 0x001a_51a3, + 0x0017_f059, + 0x001c_f175, + 0x0017_5115, + 0x0029_3059, + 0x0004_903b, + 0x0038_b265, + 0x000e_906b, + 0x000b_f0b3, + 0x002d_d1cf, + 0x000c_506b, + 0x001b_b00d, + 0x0058_106b, + 0x000f_b003, + 0x000d_3035, + 0x0006_b03d, + 0x000e_5029, + 0x0004_700d, + 0x0010_104f, + 0x0044_f2b3, + 0x0006_1017, + 0x0011_9115, + 0x0041_9083, + 0x0031_d0a7, + 0x001c_d025, + 0x000a_d00d, + 0x0003_5011, + 0x0006_700d, + 0x0028_d133, + 0x001b_70ad, + 0x001b_10a7, + 0x001e_b137, + 0x0004_9035, + 0x0010_f029, + 0x002b_31af, + 0x0014_b089, + 0x002d_d017, + 0x0017_b013, + 0x0002_5011, + 0x002e_30a3, + 0x0015_106d, + 0x002e_f239, + 0x0008_9005, + 0x001e_b017, + 0x0012_500b, + 0x000d_f03b, + 0x0036_d00b, + 0x0015_b00d, + 0x001b_b151, + 0x000e_f071, + 0x0014_b065, + 0x000e_90e3, + 0x001c_9125, + 0x003e_508b, + 0x0029_5209, + 0x0013_711b, + 0x0016_1083, + 0x007d_309d, + 0x0011_5017, + 0x0024_10e5, + 0x000b_5017, + 0x000b_3061, + 0x0045_53c7, + 0x0027_71a3, + 0x0033_d1b7, + 0x0003_b00d, + 0x0022_d00b, + 0x001b_103b, + 0x0028_d151, + 0x000d_f071, + 0x000c_7089, + 0x0010_f06d, + 0x0037_1359, + 0x0023_900d, + 0x0029_30bf, + 0x0004_f00d, + 0x004a_90b5, + 0x0006_7005, + 0x0042_50e3, + 0x001c_91af, + 0x003c_72cf, + 0x0031_300d, + 0x0067_9469, + 0x0011_506d, + 0x0018_510f, + 0x0017_b101, + 0x0023_30c7, + 0x0030_12e3, + 0x000d_f059, + 0x0033_b1bb, + 0x0002_9025, + 0x0003_b025, + 0x0023_9017, + 0x0015_102b, + 0x001b_10fb, + 0x0004_303b, + 0x0013_70e9, + 0x0058_f293, + 0x003f_5397, + 0x0020_91cf, + 0x0017_b00b, + 0x0025_10e5, + 0x0020_b011, + 0x0024_103d, + 0x0024_b241, + 0x001f_d00d, + 0x0038_f17b, + 0x0007_f043, + 0x0008_301d, + 0x000e_302b, + 0x0025_f24b, + 0x0023_3151, + 0x000e_902f, + 0x000e_904f, + 0x002b_3259, + 0x0023_b02f, + 0x000a_d043, + 0x001b_10b3, + 0x001c_f137, + 0x001c_d161, + 0x002d_70ef, + 0x0010_102f, + 0x0024_11cd, + 0x0026_50c5, + 0x0018_514b, + 0x002b_d13d, + 0x0013_7025, + 0x0008_b035, + 0x0016_111b, + 0x0009_502b, + 0x001b_7089, + 0x0011_901f, + 0x000c_10a3, + 0x0005_900d, + 0x0026_521d, + 0x0060_d305, + 0x0007_f00b, + 0x000b_f049, + 0x001a_f15d, + 0x0017_f01f, + 0x0025_f20b, + 0x002e_709d, + 0x0047_f32b, + 0x0017_5035, + 0x001b_b15d, + 0x001c_9065, + 0x0039_72a5, + 0x002a_50f1, + 0x0044_f287, + 0x0020_b0fb, + 0x0003_b02f, + 0x0013_900d, + 0x0015_100d, + 0x0020_b1a3, + 0x001b_1133, + 0x0017_b167, + 0x0035_5133, + 0x001e_b1a3, + 0x001e_b1cd, + 0x001f_d01d, + 0x0006_5029, + 0x002e_f14b, + 0x0007_1053, + 0x0013_3053, + 0x001c_918d, + 0x005c_f0b3, + 0x0028_3167, + 0x002b_d1e7, + 0x003b_30b3, + 0x0016_f025, + 0x0009_5061, + 0x0028_124b, + 0x000d_30b5, + 0x001f_d175, + 0x002d_71eb, + 0x000c_1005, + 0x0004_3029, + 0x0013_706d, + 0x003d_f0ef, + 0x0011_500d, + 0x002a_b0e5, + 0x001e_b03b, + 0x0017_b0bf, + 0x002f_902b, + 0x002a_5067, + 0x000c_5083, + 0x0026_51e7, + 0x0012_50c1, + 0x0043_f0ad, + 0x0026_9191, + 0x0013_9101, + 0x0013_300b, + 0x000b_300d, + 0x001b_1167, + 0x0025_1049, + 0x0010_109d, + 0x002e_71a3, + 0x0021_d101, + 0x0001_100d, + 0x000d_30c7, + 0x0026_9059, + 0x001c_118d, + 0x002b_d0b5, + 0x0021_d013, + 0x0022_d1e7, + 0x0014_b0d3, + 0x002b_3049, + 0x002e_315d, + 0x0013_d0fb, + 0x0016_10c1, + 0x002c_510d, + 0x0023_9125, + 0x0067_94b1, + 0x0024_1167, + 0x000f_b035, + 0x000b_5025, + 0x0025_f161, + 0x0013_d0e9, + 0x002a_5043, + 0x001a_518d, + 0x0017_b15d, + 0x0026_b115, + 0x002e_f1cf, + 0x000a_7043, + 0x000c_50b5, + 0x0037_1329, + 0x0044_50f1, + 0x0009_d005, + 0x0008_9047, + 0x0025_10e5, + 0x0028_1199, + 0x0004_302f, + 0x003f_d119, + 0x0011_90ef, + 0x003f_51b7, + 0x0009_708b, + 0x0020_b0a7, + 0x002b_3241, + 0x0012_50e9, + 0x0021_d13d, + 0x0022_d1b1, + 0x0025_9223, + 0x0035_901f, + 0x001a_30e5, + 0x0028_d06b, + 0x000e_50a3, + 0x0011_b005, + 0x0023_3185, + 0x0027_7223, + 0x001e_708b, + 0x001e_b133, + 0x0028_70f1, + 0x004c_f0b3, + 0x000f_b061, + 0x0011_b0ad, + 0x0013_70f1, + 0x001c_f049, + 0x001f_3083, + 0x002c_51a5, + 0x0013_70b5, + 0x000c_502b, + 0x0041_91af, + 0x0008_3067, + 0x0006_1043, + 0x0002_f005, + 0x002f_9025, + 0x000c_7035, + 0x001e_7067, + 0x0017_5071, + 0x0040_7373, + 0x003d_70fb, + 0x002b_d1a3, + 0x0011_510d, + 0x0011_503d, + 0x000a_7059, + 0x0008_901d, + 0x0019_1029, + 0x0025_f251, + 0x0047_f097, + 0x001d_f059, + 0x0022_314b, + 0x0022_d1b7, + 0x0002_b029, + 0x0025_718d, + 0x0015_b0df, + 0x0023_916f, + 0x001c_d071, + 0x0035_92a1, + 0x002d_71c1, + 0x0033_b2c5, + 0x0029_3259, + 0x0018_506b, + 0x0018_50a3, + 0x0014_b01d, + 0x002c_f175, + 0x000b_5013, + 0x006d_91af, + 0x0003_5007, + 0x002a_1097, + 0x0026_b03b, + 0x0021_d1c9, + 0x001c_f005, + 0x0020_b089, + 0x0022_30fb, + 0x00a3_100d, + 0x0030_5151, + 0x0026_b115, + 0x000c_70c5, + 0x000a_d0a7, + 0x0031_3223, + 0x0019_114b, + 0x000e_f0df, + 0x002a_10c1, + 0x0010_d017, + 0x0019_90fb, + 0x0028_d15d, + 0x000a_306b, + 0x001e_b043, + 0x0011_9043, + 0x0021_d1fd, + 0x001e_b071, + 0x0003_d005, + 0x003a_d00d, + 0x000d_3049, + 0x0010_d017, + 0x0058_13f1, + 0x002e_71f3, + 0x002c_51e7, + 0x002a_1011, + 0x0041_b071, + 0x0018_5151, + 0x000c_7067, + 0x0006_b03b, + 0x0012_5061, + 0x0020_91a5, + 0x000d_f06d, + 0x0071_3043, + 0x001a_315b, + 0x0019_900b, + 0x001e_7185, + 0x0044_533d, + 0x003c_b2a1, + 0x0004_f017, + 0x000e_5047, + 0x001e_707f, + 0x0006_d00d, + 0x001b_7089, + 0x0016_101d, + 0x0015_b03b, + 0x0004_9005, + 0x002a_b223, + 0x000c_703d, + 0x002b_3251, + 0x000b_3097, + 0x0011_50e5, + 0x0024_b1cd, + 0x0020_91b7, + 0x0034_700d, + 0x001f_706d, + 0x0010_f035, + 0x0017_f14b, + 0x001c_914b, + 0x001a_f0bf, + 0x000d_3059, + 0x0010_f0f1, + 0x0008_300d, + 0x000d_f00d, + 0x0003_d00d, + 0x0031_32e3, + 0x0031_d2a1, + 0x0041_b33b, + 0x001b_7115, + 0x002c_50d3, + 0x001d_310f, + 0x0032_b24b, + 0x0005_301f, + 0x002a_517b, + 0x0031_d18d, + 0x001a_f17b, + 0x000e_f01f, + 0x001b_b17b, + 0x000b_3053, + 0x001a_f14b, + 0x0018_d15b, + 0x002a_b00d, + 0x0016_10a7, + 0x0019_90ef, + 0x0003_500d, + 0x0015_10fb, + 0x003a_9175, + 0x0011_90b5, + 0x000a_703b, + 0x0028_3259, + 0x003c_7277, + 0x000d_3043, + 0x0022_d0b5, + 0x0013_d005, + 0x003e_536d, + 0x002d_d005, + 0x0022_30bf, + 0x0009_702f, + 0x000a_d03d, + 0x0019_10a3, + 0x0000_d00b, + 0x0026_50c7, + 0x0033_d283, + 0x0025_9175, + 0x000c_703d, + 0x0019_90b3, + 0x0010_f0e3, + 0x0001_7013, + 0x002f_50d3, + 0x001b_702f, + 0x000c_5097, + 0x0003_b005, + 0x0033_b295, + 0x0025_f0ad, + 0x003a_10fb, + 0x001f_71df, + 0x000b_f08b, + 0x000a_7013, + 0x000e_3071, + 0x0006_5025, + 0x0011_50c1, + 0x000e_501d, + 0x000a_707f, + 0x001c_d0c5, + 0x0016_1107, + 0x0031_d293, + 0x0001_d00d, + 0x0013_7053, + 0x0016_110d, + 0x001d_3161, + 0x001a_f0bf, + 0x001d_f16f, + 0x0011_5013, + 0x0013_7043, + 0x0044_f11b, + 0x000d_f06b, + 0x0006_5025, + 0x0013_d0b5, + 0x0008_3029, + 0x002d_d0b5, + 0x002c_5293, + 0x001c_f03b, + 0x0048_b33b, + 0x001b_7133, + 0x002d_71a3, + 0x001d_f011, + 0x0002_b029, + 0x0015_d053, + 0x0019_90a3, + 0x0033_d2b3, + 0x0013_904f, + 0x0030_52e3, + 0x000d_f095, + 0x0013_908b, + 0x002a_1265, + 0x003d_10c5, + 0x0017_b151, + 0x003c_b15b, + 0x0022_d1a3, + 0x002c_f1c9, + 0x001c_90df, + 0x0018_500d, + 0x001c_d1a3, + 0x0020_b16f, + 0x003a_d28d, + 0x0017_b133, + 0x0022_3137, + 0x0018_d16f, + 0x0019_901d, + 0x0020_902b, + 0x0035_500b, + 0x000a_d0a7, + 0x0026_b005, + 0x0013_3025, + 0x0019_100d, + 0x0029_51cd, + 0x0025_704f, + 0x0017_5005, + 0x000a_d06b, + 0x0048_b133, + 0x0011_50b3, + 0x0015_b0a7, + 0x000f_106b, + 0x0013_7097, + 0x0010_703b, + 0x0021_d11b, + 0x001e_b115, + 0x0031_d15d, + 0x002b_30ad, + 0x002e_702f, + 0x002b_d005, + 0x0029_3025, + 0x0010_f083, + 0x0027_710d, + 0x001c_1167, + 0x000e_f067, + 0x0017_515d, + 0x0022_3013, + 0x0025_904f, + 0x0026_5137, + 0x0023_9017, + 0x003f_522d, + 0x001a_f005, + 0x001a_302b, + 0x000b_f049, + 0x000e_5047, + 0x000c_70b5, + 0x003f_501d, + 0x000e_f07f, + 0x0028_1161, + 0x0044_910f, + 0x0015_b029, + 0x002a_107f, + 0x0019_1095, + 0x0019_100d, + 0x0061_f107, + 0x003f_1371, + 0x0010_10c5, + 0x0005_3043, + 0x0003_b017, + 0x001b_1115, + 0x0018_d0f1, + 0x001a_30df, + 0x005b_f55d, + 0x003f_50c1, + 0x0032_90df, + 0x0030_5139, + 0x001f_7097, + 0x0008_903d, + 0x0017_b0a3, + 0x0027_7089, + 0x0011_b02b, + 0x000e_9025, + 0x0022_3083, + 0x000c_70b3, + 0x0035_b359, + 0x0022_3115, + 0x0064_d191, + 0x001e_71d3, + 0x0043_f175, + 0x0014_b0ef, + 0x000c_7049, + 0x0050_932b, + 0x000b_f065, + 0x001f_3083, + 0x0024_b0a3, + 0x0002_b011, + 0x000d_f0c5, + 0x0019_100d, + 0x0008_9061, + 0x0016_109d, + 0x0007_1047, + 0x004c_f3e5, + 0x0016_7003, + 0x004c_13e5, + 0x000c_10ad, + 0x0007_f03d, + 0x0009_508b, + 0x001c_10a7, + 0x0011_90a7, + 0x0022_3137, + 0x0003_b025, + 0x001c_d03d, + 0x0023_b17b, + 0x0008_903d, + 0x0009_d071, + 0x0035_913d, + 0x001d_f0a3, + 0x0006_700d, + 0x0025_f1a5, + 0x002d_d199, + 0x001a_f0e5, + 0x0023_b0bf, + 0x000d_3067, + 0x0029_31e7, + 0x0060_d2a1, + 0x000e_50e3, + 0x001c_118d, + 0x0048_1067, + 0x0015_d065, + 0x0027_700d, + 0x003d_118d, + 0x0025_7107, + 0x0023_b0ad, + 0x0002_5011, + 0x0006_d029, + 0x0012_5053, + 0x001d_f175, + 0x002e_f02b, + 0x0026_b199, + 0x0007_1049, + 0x0038_f065, + 0x0015_b02b, + 0x0011_903b, + 0x0003_5029, + 0x0044_33fd, + 0x0009_d01d, + 0x000e_302b, + 0x0014_b053, + 0x0036_d1af, + 0x0007_1047, + 0x0037_700d, + 0x000b_3047, + 0x002e_f125, + 0x000d_30bf, + 0x0009_7005, + 0x000e_3071, + 0x000e_9071, + 0x0018_d0bf, + 0x0006_1017, + 0x000f_1005, + 0x004a_9241, + 0x0005_302b, + 0x001b_b065, + 0x0015_b115, + 0x0022_d125, + 0x001c_1065, + 0x0035_92bd, + 0x002c_52bd, + 0x0013_70df, + 0x002a_5139, + 0x000f_b013, + 0x002e_701f, + 0x0004_701d, + 0x002e_f2bd, + 0x002b_d083, + 0x000a_704f, + 0x00b1_b5d1, + 0x0035_9295, + 0x001c_f0ef, + 0x0006_d025, + 0x0011_5005, + 0x0025_10b5, + 0x0014_b049, + 0x0009_7047, + 0x0006_b061, + 0x0010_10ef, + 0x000d_303d, + 0x002a_10e9, + 0x0040_718d, + 0x0013_7029, + 0x001a_30b5, + 0x001f_313d, + 0x0021_d0df, + 0x000a_7097, + 0x0005_300d, + 0x0013_d00d, + 0x0033_b119, + 0x0016_f0c5, + 0x000c_1013, + 0x000f_b0a7, + 0x0022_3043, + 0x0000_b005, + 0x0033_718d, + 0x001a_3029, + 0x000b_f049, + 0x000f_1065, + 0x0010_7007, + 0x0015_d097, + 0x0014_b04f, + 0x0041_b20b, + 0x0005_9029, + 0x0030_10df, + 0x0036_d02f, + 0x0008_b06b, + 0x000c_5007, + 0x000e_9029, + 0x001a_30c7, + 0x001f_d0e9, + 0x0012_5095, + 0x0045_508b, + 0x002c_f17f, + 0x0001_700d, + 0x0015_1043, + 0x000a_d04f, + 0x000b_f0b5, + 0x0010_f0a3, + 0x0011_b04f, + 0x0020_b209, + 0x001b_113d, + 0x000d_303b, + 0x000d_306b, + 0x0007_f06b, + 0x0017_b03d, + 0x0033_b2b3, + 0x0025_907f, + 0x004f_d18d, + 0x0010_d0a7, + 0x001d_f119, + 0x000b_f005, + 0x0017_f0b3, + 0x0016_1071, + 0x0008_b00d, + 0x000a_d071, + 0x001c_f0d3, + 0x0015_d005, + 0x0025_922d, + 0x0031_3209, + 0x0013_3025, + 0x0022_31a3, + 0x000f_b007, + 0x0033_5139, + 0x0028_3013, + 0x0016_1005, + 0x0026_b115, + 0x0024_11a5, + 0x000b_302b, + 0x002e_f1c9, + 0x0020_9199, + 0x0013_d089, + 0x0028_120b, + 0x0016_f065, + 0x001a_500d, + 0x0019_9101, + 0x0011_50e5, + 0x0023_922d, + 0x0037_31eb, + 0x0010_f065, + 0x000e_9017, + 0x0018_d01d, + 0x0027_7053, + 0x0005_9047, + 0x001b_7097, + 0x0003_5013, + 0x0000_d00b, + 0x0007_1061, + 0x0014_b04f, + 0x000c_1025, + 0x001f_70fb, + 0x0026_524b, + 0x0082_91c1, + 0x0002_f025, + 0x004a_91cd, + 0x004a_3095, + 0x0024_b0ad, + 0x0064_94a9, + 0x0016_1049, + 0x0015_b0a7, + 0x0009_d03d, + 0x000b_503b, + 0x000f_10bf, + 0x0016_70a3, + 0x0007_f013, + 0x0012_508b, + 0x0011_b0e5, + 0x000c_50b3, + 0x0025_90ef, + 0x001d_f10d, + 0x001b_1191, + 0x000f_101d, + 0x000e_9047, + 0x0023_3161, + 0x0046_3067, + 0x004c_14a3, + 0x0008_3025, + 0x000a_d065, + 0x0026_b10f, + 0x0025_f03d, + 0x0044_540f, + 0x0006_d03d, + 0x0018_d061, + 0x0003_b017, + 0x0002_f01d, + 0x0011_b035, + 0x0023_300d, + 0x001e_b1e7, + 0x000e_9043, + 0x0017_f107, + 0x000c_5043, + 0x002a_b21d, + 0x0012_5065, + 0x0017_f089, + 0x0008_301d, + 0x0004_f02b, + 0x001c_f10d, + 0x0004_301d, + 0x002f_90fb, + 0x0024_b17b, + 0x000b_500d, + 0x0033_7053, + 0x0031_d0df, + 0x0042_d0df, + 0x0009_706b, + 0x0003_d00d, + 0x0025_f185, + 0x000e_f0a3, + 0x002c_5101, + 0x000b_500d, + 0x0008_9005, + 0x001b_10d3, + 0x0007_100d, + 0x001b_700d, + 0x0011_90e3, + 0x0002_500d, + 0x001f_301f, + 0x000e_5017, + 0x002a_b20b, + 0x0018_d047, + 0x0011_90b5, + 0x001a_518d, + 0x0024_114b, + 0x0023_b0ad, + 0x0009_d065, + 0x0059_90c1, + 0x0025_90c7, + 0x0023_b199, + 0x0026_b1a5, + 0x0009_d02b, + 0x000c_50c1, + 0x002e_7185, + 0x001b_107f, + 0x0025_7011, + 0x000f_1097, + 0x0008_b043, + 0x0015_d0c7, + 0x0004_9011, + 0x000b_f043, + 0x0021_d03b, + 0x0026_50f1, + 0x001c_10f1, + 0x0032_9161, + 0x001e_702b, + 0x0007_1007, + 0x0007_102f, + 0x0004_700b, + 0x001b_7095, + 0x0006_b061, + 0x0023_31af, + 0x001b_71a3, + 0x0025_1043, + 0x0016_10e3, + 0x000c_70b3, + 0x000d_f017, + 0x002c_f0a3, + 0x0023_30b5, + 0x0021_d14b, + 0x0015_1115, + 0x0022_d21d, + 0x001c_f07f, + 0x000b_500d, + 0x001b_b025, + 0x0015_10c7, + 0x0060_d347, + 0x0037_3005, + 0x0002_b00d, + 0x0010_d097, + 0x000a_303b, + 0x0008_906b, + 0x002d_d0b3, + 0x0038_f1e7, + 0x0027_70e9, + 0x000b_50a7, + 0x001a_f065, + 0x001b_1053, + 0x001c_902f, + 0x0011_5013, + 0x0006_1013, + 0x0044_90bf, + 0x003f_503b, + 0x0003_b00d, + 0x002e_326b, + 0x0031_d1af, + 0x0028_30b5, + 0x001e_7175, + 0x000e_300b, + 0x002c_5133, + 0x002d_71eb, + 0x0023_9199, + 0x0006_1005, + 0x001e_b025, + 0x000e_90b3, + 0x0028_3133, + 0x0017_50f1, + 0x001f_d191, + 0x0009_d053, + 0x001e_b025, + 0x002d_71b7, + 0x0010_d0b5, + 0x000c_702f, + 0x0044_516f, + 0x003f_5043, + 0x0009_702f, + 0x0019_9083, + 0x0008_9043, + 0x000b_f071, + 0x0016_710f, + 0x0011_501d, + 0x0011_90ad, + 0x0025_10fb, + 0x001c_f17f, + 0x000f_b0b3, + 0x0039_731d, + 0x002d_d28d, + 0x000f_b003, + 0x0023_907f, + 0x0016_f119, + 0x001a_f199, + 0x001b_b115, + 0x001f_3115, + 0x0029_525f, + 0x0023_b10d, + 0x000a_306d, + 0x0010_d0e5, + 0x0009_d097, + 0x0009_7025, + 0x0035_b137, + 0x0020_b17b, + 0x0022_d00d, + 0x0004_f013, + 0x0011_9011, + 0x0011_b0e3, + 0x0017_f151, + 0x001c_909d, + 0x001c_1107, + 0x0000_b005, + 0x0032_9005, + 0x0011_902f, + 0x0025_f125, + 0x0023_91df, + 0x0015_d071, + 0x0016_f067, + 0x001d_f1b1, + 0x001f_d01f, + 0x0044_f1a3, + 0x002c_5251, + 0x0026_b101, + 0x0016_7067, + 0x0002_5005, + 0x0035_9119, + 0x0013_d10f, + 0x0002_b00d, + 0x0007_1053, + 0x0009_d02b, + 0x0024_b15d, + 0x003d_11e7, + 0x0009_702f, + 0x0044_51d3, + 0x0023_313d, + 0x000e_906d, + 0x0026_5209, + 0x0056_555d, + 0x0007_1067, + 0x0035_520b, + 0x000e_909d, + 0x0016_f0fb, + 0x0001_f00d, + 0x0040_7047, + 0x0035_5251, + 0x0023_30c5, + 0x0031_d2a5, + 0x0011_504f, + 0x000c_701d, + 0x002c_f003, + 0x0037_3071, + 0x0005_9013, + 0x0046_3449, + 0x000e_f065, + 0x002d_d233, + 0x0018_d083, + 0x001c_f14b, + 0x0012_5061, + 0x0015_10f1, + 0x000b_503d, + 0x003c_b24b, + 0x001c_904f, + 0x000b_301f, + 0x003e_511b, + 0x0020_b025, + 0x0031_32dd, + 0x0013_901d, + 0x002b_d067, + 0x0025_723b, + 0x0009_508b, + 0x000c_500b, + 0x0033_514b, + 0x0015_1065, + 0x0011_901d, + 0x001b_10a3, + 0x000c_70a7, + 0x005d_5329, + 0x002e_304f, + 0x000e_f003, + 0x000b_5067, + 0x0017_5125, + 0x0037_71b1, + 0x000c_103d, + 0x0025_924b, + 0x0016_700b, + 0x0042_71cd, + 0x0010_d02f, + 0x0025_103d, + 0x0051_50c7, + 0x0023_310f, + 0x0012_50b5, + 0x0022_d133, + 0x0013_30c1, + 0x000b_f0ad, + 0x0009_500b, + 0x0004_3035, + 0x0028_70fb, + 0x0022_d0b5, + 0x001f_d139, + 0x002e_7101, + 0x000e_30b5, + 0x0005_302f, + 0x001f_715d, + 0x0006_101d, + 0x000f_1089, + 0x001e_b025, + 0x000f_b071, + 0x001c_1151, + 0x0017_f0c5, + 0x0013_3059, + 0x0009_d03d, + 0x0026_91e7, + 0x0011_b0df, + 0x001e_7035, + 0x0009_d035, + 0x003d_72dd, + 0x000d_3061, + 0x0017_5061, + 0x000e_9089, + 0x000a_3061, + 0x0006_7053, + 0x0013_3029, + 0x002c_f1a5, + 0x000a_3065, + 0x0033_717b, + 0x0016_7151, + 0x0011_9101, + 0x0033_5005, + 0x0005_9011, + 0x0018_5011, + 0x0025_70e9, + 0x002d_d09d, + 0x0027_715b, + 0x000e_5089, + 0x0023_3053, + 0x000d_f04f, + 0x0033_d2ef, + 0x002e_30c1, + 0x000f_1007, + 0x0064_d5c9, + 0x0006_5059, + 0x000a_d059, + 0x001d_310f, + 0x002e_7049, + 0x0051_5493, + 0x0017_f07f, + 0x000b_5059, + 0x0045_523b, + 0x001b_b035, + 0x0002_f017, + 0x0013_9083, + 0x0002_900d, + 0x001c_109d, + 0x004c_d335, + 0x0019_9139, + 0x002e_f025, + 0x0032_b059, + 0x0023_b013, + 0x0022_30fb, + 0x003b_311b, + 0x0000_7005, + 0x0022_d0fb, + 0x0001_d011, + 0x001a_3061, + 0x0001_d00d, + 0x0049_d42d, + 0x002b_d1af, + 0x002e_7223, + 0x0004_302f, + 0x0034_7337, + 0x001e_70a7, + 0x000d_f0ad, + 0x0019_10c5, + 0x002b_d035, + 0x0017_b089, + 0x000e_500d, + 0x0002_5013, + 0x005d_523b, + 0x002e_720b, + 0x0029_3185, + 0x0011_b04f, + 0x001f_30df, + 0x0018_5061, + 0x0043_f16f, + 0x003f_13c7, + 0x0017_5151, + 0x000e_30a7, + 0x0021_d1bb, + 0x002c_f067, + 0x001d_3139, + 0x004e_b443, + 0x000e_f01f, + 0x0021_d0ad, + 0x0029_50b5, + 0x001f_70ad, + 0x001d_3061, + 0x0017_b139, + 0x0019_1005, + 0x0030_1089, + 0x007d_b209, + 0x000a_d017, + 0x0025_9029, + 0x0026_9035, + 0x0013_d06d, + 0x0033_5083, + 0x001c_f0bf, + 0x0006_d011, + 0x0013_90d3, + 0x0063_d44f, + 0x0013_90a3, + 0x0052_9281, + 0x0042_d0ef, + 0x000c_501d, + 0x0010_d083, + 0x0011_5071, + 0x001a_511b, + 0x0028_1107, + 0x0024_b1a3, + 0x0005_901d, + 0x0018_500d, + 0x0013_9059, + 0x0023_90ad, + 0x0013_d125, + 0x003a_d371, + 0x000c_7043, + 0x0041_b0e9, + 0x0016_703d, + 0x0013_910f, + 0x000b_f043, + 0x0042_d2dd, + 0x003b_3167, + 0x002c_f00d, + 0x001c_100d, + 0x0049_d0e9, + 0x0008_3065, + 0x0024_b0ef, + 0x001c_d00d, + 0x0028_11af, + 0x001d_f1c9, + 0x0013_9115, + 0x001e_b1af, + 0x001c_f175, + 0x0023_317b, + 0x002b_31d3, + 0x0010_f0a7, + 0x000e_f061, + 0x0002_9005, + 0x0019_114b, + 0x0026_5043, + 0x001f_31d3, + 0x000f_b089, + 0x0011_b089, + 0x0005_9013, + 0x0042_d089, + 0x0031_d011, + 0x0028_3095, + 0x0018_5137, + 0x0013_7035, + 0x0021_d0ad, + 0x000e_5025, + 0x000b_3029, + 0x0029_325f, + 0x0018_5089, + 0x0042_53b3, + 0x000b_50a3, + 0x0031_3035, + 0x000a_d08b, + 0x0011_90a7, + 0x0025_f233, + 0x0026_5035, + 0x001b_b053, + 0x001c_9005, + 0x0007_1035, + 0x0016_f10d, + 0x000f_b0e9, + 0x000f_10e5, + 0x0024_10d3, + 0x0010_d095, + 0x0010_701f, + 0x0011_506b, + 0x001d_f04f, + 0x000e_f00b, + 0x0019_10ef, + 0x002a_115d, + 0x002c_f18d, + 0x000d_f025, + 0x0026_50ef, + 0x0003_d011, + 0x005a_d371, + 0x0018_d053, + 0x001b_101d, + 0x0017_f01f, + 0x001f_d137, + 0x001e_b161, + 0x0016_70c5, + 0x0026_b1cd, + 0x0024_b0f1, + 0x0010_1067, + 0x0033_51e7, + 0x001f_715b, + 0x001f_d137, + 0x0023_b22d, + 0x0001_300b, + 0x0025_702b, + 0x0025_1083, + 0x0004_900b, + 0x000e_3047, + 0x0027_700d, + 0x0001_d017, + 0x001b_70c5, + 0x001b_7161, + 0x0017_b029, + 0x000e_9047, + 0x002a_b15d, + 0x002c_f175, + 0x001d_301f, + 0x005b_351b, + 0x003b_900d, + 0x000c_5053, + 0x0003_d013, + 0x0043_f043, + 0x0006_b061, + 0x0010_106b, + 0x0013_7011, + 0x0001_700d, + 0x0013_3053, + 0x0013_70fb, + 0x0065_3005, + 0x0015_b0df, + 0x001c_1083, + 0x001a_f125, + 0x001f_7167, + 0x0017_f0b3, + 0x0017_b011, + 0x0028_7137, + 0x001a_f06d, + 0x0016_f00b, + 0x0018_507f, + 0x0015_d0f1, + 0x0004_7017, + 0x0060_d4cd, + 0x002d_d0e9, + 0x0051_1025, + 0x002e_f01f, + 0x0006_7053, + 0x0017_f03b, + 0x0002_501d, + 0x000b_500d, + 0x0006_7049, + 0x0036_d233, + 0x0044_911b, + 0x0002_9025, + 0x002f_50bf, + 0x0020_b02b, + 0x0015_108b, + 0x002c_51a3, + 0x002e_7097, + 0x001c_f047, + 0x0016_106b, + 0x004f_d2c5, + 0x0013_7043, + 0x0030_1043, + 0x0036_d2ef, + 0x0019_106b, + 0x005b_3133, + 0x0016_7053, + 0x0028_7119, + 0x002f_503d, + 0x0025_10d3, + 0x0037_3083, + 0x002c_5167, + 0x0015_b049, + 0x0008_b011, + 0x0004_7025, + 0x000e_5025, + 0x0006_103d, + 0x002f_91e7, + 0x0017_f133, + 0x0046_3449, + 0x0010_f0b3, + 0x0032_9029, + 0x0048_b35b, + 0x0035_b0e9, + 0x002a_1125, + 0x000e_f061, + 0x002c_5053, + 0x0035_b2dd, + 0x000d_f0c5, + 0x0006_5011, + 0x0049_d1fd, + 0x0041_b397, + 0x0006_103d, + 0x001e_b0e3, + 0x002f_913d, + 0x0011_9005, + 0x000f_102f, + 0x0031_d239, + 0x0011_50e3, + 0x0006_703b, + 0x0013_7119, + 0x0011_b043, + 0x0008_306b, + 0x002b_30df, + 0x0006_5059, + 0x0024_b0d3, + 0x0014_b0df, + 0x002a_b223, + 0x0028_10e3, + 0x0004_f03d, + 0x0023_91af, + 0x000b_f049, + 0x0017_501f, + 0x000b_3059, + 0x000a_d097, + 0x001b_706d, + 0x000b_301d, + 0x0004_3017, + 0x0018_d011, + 0x0062_f0c1, + 0x0025_71bb, + 0x0024_117b, + 0x0012_501f, + 0x001e_70d3, + 0x0013_30bf, + 0x000f_b0b5, + 0x0037_3191, + 0x0010_100d, + 0x000f_1053, + 0x001a_f0fb, + 0x000a_d005, + 0x002e_f125, + 0x0037_335f, + 0x0006_7025, + 0x0017_b035, + 0x002d_d28d, + 0x0019_1101, + 0x000a_d047, + 0x002a_115d, + 0x000d_f097, + 0x0032_90ef, + 0x0030_120b, + 0x0033_b337, + 0x000e_90c5, + 0x0034_70bf, + 0x000b_f0b5, + 0x0017_f0b3, + 0x0013_700d, + 0x0013_d017, + 0x0017_b167, + 0x0016_10ef, + 0x003a_90f1, + 0x000a_d02f, + 0x0037_124b, + 0x001d_f1c1, + 0x000a_d01f, + 0x0031_d18d, + 0x0009_d047, + 0x0028_71c1, + 0x0020_b035, + 0x001d_f0c5, + 0x0025_904f, + 0x001a_504f, + 0x0021_d0b3, + 0x001b_b0ad, + 0x000e_900b, + 0x0007_f01d, + 0x000e_301f, + 0x0004_9005, + 0x0010_706d, + 0x0021_d17f, + 0x0008_304f, + 0x000c_103b, + 0x0018_517b, + 0x001e_b1cf, + 0x0001_d005, + 0x000c_700b, + 0x0004_f035, + 0x0001_100d, + 0x0028_10e9, + 0x0031_32b3, + 0x002d_7239, + 0x0025_1061, + 0x002a_120b, + 0x000b_f00d, + 0x001f_310d, + 0x0023_b0f1, + 0x0052_7025, + 0x0011_910f, + 0x0041_9139, + 0x0020_b095, + 0x0026_910d, + 0x0038_b359, + 0x002c_f1a5, + 0x0021_d0b5, + 0x0025_101d, + 0x003a_d0c1, + 0x004c_d2b3, + 0x002a_50bf, + 0x0004_f025, + 0x001f_7089, + 0x0007_1049, + 0x0026_b133, + 0x002d_d239, + 0x002e_3025, + 0x0044_91a3, + 0x0028_11cf, + 0x0031_307f, + 0x0018_d167, + 0x0009_707f, + 0x0025_70c5, + 0x000b_f00d, + 0x0032_b2dd, + 0x0004_3025, + 0x0005_9025, + 0x0010_f0a3, + 0x0009_d067, + 0x0026_524b, + 0x0019_110f, + 0x001b_70a7, + 0x0017_f107, + 0x0023_3139, + 0x0004_900d, + 0x0056_54cd, + 0x002a_522d, + 0x001c_1043, + 0x0055_1133, + 0x001b_7199, + 0x0004_3025, + 0x001a_317b, + 0x0004_9047, + 0x0015_b0c5, + 0x0022_313d, + 0x001b_1043, + 0x001a_300b, + 0x0016_1133, + 0x0023_308b, + 0x0014_b09d, + 0x0011_90d3, + 0x000c_5029, + 0x0013_d06d, + 0x0025_9035, + 0x001b_b047, + 0x0007_f043, + 0x001e_b10d, + 0x001b_b09d, + 0x000f_b03b, + 0x0019_100d, + 0x001c_f0c5, + 0x0005_900b, + 0x0010_7035, + 0x001d_3005, + 0x0010_1025, + 0x0020_b06d, + 0x001e_b1a3, + 0x0023_308b, + 0x0018_513d, + 0x000c_1059, + 0x0010_7025, + 0x0046_302f, + 0x000d_f061, + 0x0010_f00d, + 0x001f_303b, + 0x0011_90e3, + 0x0016_f0c7, + 0x0023_31e7, + 0x001c_f185, + 0x001b_7065, + 0x0013_310f, + 0x0009_5053, + 0x0018_d0e9, + 0x0009_d013, + 0x0007_1059, + 0x000f_b0bf, + 0x001a_f0e3, + 0x0014_b013, + 0x0006_7047, + 0x000c_10b5, + 0x0033_70a7, + 0x0006_b01d, + 0x008e_1685, + 0x0011_b03b, + 0x005b_f269, + 0x0024_10c1, + 0x0033_5301, + 0x0019_9013, + 0x0003_501f, + 0x0035_925f, + 0x0033_7137, + 0x002d_d071, + 0x0035_9151, + 0x0062_31b1, + 0x004f_f305, + 0x0000_d005, + 0x0002_500d, + 0x002d_d1f7, + 0x0025_70e5, + 0x0028_716f, + 0x000b_5011, + 0x0009_7059, + 0x000a_d09d, + 0x0033_d0bf, + 0x000e_500b, + 0x0030_51fd, + 0x000f_b011, + 0x002e_72bd, + 0x001c_d1c1, + 0x000e_f00d, + 0x0017_5017, + 0x001d_3191, + 0x0008_300d, + 0x0019_9133, + 0x0008_b029, + 0x000c_5005, + 0x0049_d071, + 0x0022_3209, + 0x000b_f083, + 0x0007_100d, + 0x001b_b125, + 0x000a_3095, + 0x0023_31a3, + 0x001c_9005, + 0x002f_9025, + 0x004b_d481, + 0x0027_70a3, + 0x0085_f0ef, + 0x0009_5049, + 0x001c_90e3, + 0x0015_d02b, + 0x0028_d029, + 0x003d_f08b, + 0x0011_9047, + 0x004b_d2ab, + 0x0036_d08b, + 0x0019_9097, + 0x000f_b02f, + 0x0049_306d, + 0x001f_3161, + 0x001a_3013, + 0x000f_b0df, + 0x000e_30a3, + 0x0025_11fd, + 0x0026_525f, + 0x0013_910d, + 0x0042_73ad, + 0x0013_3035, + 0x0012_50d3, + 0x0052_f38b, + 0x002e_7223, + 0x000b_f097, + 0x0013_d0b3, + 0x0018_d013, + 0x0028_70b5, + 0x0021_d16f, + 0x0057_7005, + 0x0006_100d, + 0x0020_9089, + 0x0013_70ad, + 0x0035_515d, + 0x0013_d0c7, + 0x001a_f16f, + 0x000b_5035, + 0x0006_d049, + 0x002e_71f3, + 0x0030_12dd, + 0x0013_d10d, + 0x0017_f059, + 0x0006_702b, + 0x003c_7137, + 0x001b_b00d, + 0x0005_3047, + 0x002d_d281, + 0x002e_32d7, + 0x000b_f03b, + 0x0013_701d, + 0x002f_520b, + 0x0017_f01d, + 0x0011_5089, + 0x004c_1191, + 0x0020_b049, + 0x0006_100b, + 0x001c_d101, + 0x001a_f029, + 0x0044_3151, + 0x0004_900d, + 0x0013_703d, + 0x001d_f139, + 0x001b_71a3, + 0x0002_5005, + 0x0015_102f, + 0x001a_3133, + 0x0021_d1e7, + 0x0015_d09d, + 0x0033_d06b, + 0x001b_b043, + 0x0018_500d, + 0x000a_7047, + 0x001e_71d3, + 0x001f_7191, + 0x001c_9071, + 0x000c_702b, + 0x0015_b095, + 0x0013_d08b, + 0x004e_b005, + 0x003d_f251, + 0x000e_302f, + 0x000e_3047, + 0x0004_903b, + 0x0027_7043, + 0x000f_10e3, + 0x000b_5005, + 0x0038_f31d, + 0x0056_5407, + 0x002e_f22d, + 0x001d_3107, + 0x0006_d029, + 0x0031_d25f, + 0x001c_f00d, + 0x0028_d139, + 0x001c_d10f, + 0x0001_f00d, + 0x0046_32dd, + 0x0012_50c5, + 0x0008_b035, + 0x0013_d0b5, + 0x000b_508b, + 0x0016_f00d, + 0x0022_3061, + 0x0029_5107, + 0x0010_d03d, + 0x0023_b107, + 0x0016_10e3, + 0x001a_3083, + 0x0015_b0bf, + 0x0023_b09d, + 0x0012_5043, + 0x0025_71af, + 0x002c_503b, + 0x003c_7259, + 0x001c_f0b5, + 0x0010_70ad, + 0x0020_91f3, + 0x0017_507f, + 0x0030_10a7, + 0x001c_90bf, + 0x0022_30e3, + 0x0025_1133, + 0x002b_310d, + 0x0013_d00d, + 0x000e_309d, + 0x0029_51f7, + 0x000b_300d, + 0x0013_30b5, + 0x0024_b061, + 0x0025_7053, + 0x0017_b013, + 0x004c_732b, + 0x0024_b00d, + 0x0013_d02f, + 0x0024_b151, + 0x0000_b005, + 0x0004_300d, + 0x0017_b007, + 0x0015_1005, + 0x0026_900b, + 0x000c_504f, + 0x000b_f06d, + 0x004e_149d, + 0x001d_302b, + 0x0038_b029, + 0x0037_10ad, + 0x0032_b07f, + 0x000b_f0b5, + 0x000e_3005, + 0x0015_10bf, + 0x002a_5139, + 0x0033_707f, + 0x0059_53e5, + 0x001c_911b, + 0x0025_9071, + 0x003a_1119, + 0x0009_508b, + 0x0010_f047, + 0x003a_1287, + 0x0023_31af, + 0x0016_100b, + 0x002f_91f3, + 0x0008_304f, + 0x001a_50fb, + 0x000e_f0d3, + 0x0011_500d, + 0x0012_5029, + 0x000e_f0c7, + 0x001c_91a5, + 0x003c_718d, + 0x000e_903d, + 0x000e_f08b, + 0x0028_3281, + 0x0019_90b3, + 0x0017_f083, + 0x001f_7003, + 0x0029_31f7, + 0x0017_516f, + 0x000b_5005, + 0x0016_70c7, + 0x0039_71eb, + 0x0029_511b, + 0x000b_508b, + 0x001f_311b, + 0x0030_5161, + 0x0028_d0df, + 0x003e_510f, + 0x0023_9083, + 0x0042_d3fd, + 0x0014_b013, + 0x0013_90d3, + 0x001d_f1bb, + 0x0009_d03d, + 0x002b_3175, + 0x0024_11c1, + 0x0015_d01f, + 0x0016_f03d, + 0x000c_507f, + 0x0009_7007, + 0x002a_502f, + 0x003d_71e7, + 0x0006_d065, + 0x002d_d02b, + 0x000a_7013, + 0x001c_d06d, + 0x0018_516f, + 0x0015_d0e5, + 0x0014_b13d, + 0x001a_50ef, + 0x0028_70e3, + 0x0020_91e7, + 0x0050_9043, + 0x0040_708b, + 0x000c_50c1, + 0x0017_516f, + 0x0013_302f, + 0x001b_1071, + 0x0005_301d, + 0x0011_90a7, + 0x0013_30ef, + 0x000a_7095, + 0x0030_110f, + 0x0022_3185, + 0x001c_f089, + 0x000b_3059, + 0x0016_7151, + 0x0025_1095, + 0x000f_b04f, + 0x0005_3035, + 0x001d_f1b7, + 0x0037_1283, + 0x001c_1107, + 0x0017_5043, + 0x0029_3053, + 0x003c_b32b, + 0x0014_b02f, + 0x001a_f107, + 0x000e_50ad, + 0x0017_5061, + 0x0028_d0b3, + 0x002c_50b3, + 0x0017_b0a3, + 0x000e_30a3, + 0x0015_b011, + 0x0024_113d, + 0x0021_d03d, + 0x003b_3107, + 0x0035_910f, + 0x0002_f00d, + 0x001e_b0b3, + 0x0028_d185, + 0x000b_500b, + 0x001b_702f, + 0x000e_9049, + 0x003f_d03d, + 0x0048_1017, + 0x0030_511b, + 0x001b_1101, + 0x001c_d053, + 0x000f_10b3, + 0x0008_900d, + 0x000f_b0c5, + 0x0013_d0c1, + 0x002f_926b, + 0x0036_d287, + 0x0033_b2f5, + 0x002e_f1e7, + 0x0044_5133, + 0x0003_b011, + 0x0067_9283, + 0x0010_103d, + 0x0011_50ad, + 0x001a_f059, + 0x0008_9025, + 0x0028_1185, + 0x001c_9035, + 0x0023_9065, + 0x0007_f01f, + 0x003b_92dd, + 0x0019_10b5, + 0x001e_b1c1, + 0x001c_d1a3, + 0x0021_d1d3, + 0x0007_f06d, + 0x0000_d00b, + 0x002c_51d3, + 0x002f_9025, + 0x001c_d007, + 0x000c_700d, + 0x000c_102f, + 0x0033_d101, + 0x0015_b02b, + 0x001f_d0e5, + 0x0003_b01d, + 0x0015_1107, + 0x0028_11af, + 0x0040_7241, + 0x0002_b01d, + 0x000a_7029, + 0x001d_f1c1, + 0x0005_302f, + 0x0025_7007, + 0x0003_b029, + 0x0017_500d, + 0x001a_30b3, + 0x003c_b0d3, + 0x002a_510d, + 0x0015_b125, + 0x0013_d059, + 0x001e_b083, + 0x000a_707f, + 0x0023_30ad, + 0x0018_d035, + 0x000b_302b, + 0x0051_508b, + 0x0016_1133, + 0x000b_f047, + 0x0015_b107, + 0x0039_72d7, + 0x003f_107f, + 0x0024_11fd, + 0x000b_f025, + 0x001f_30a7, + 0x000e_507f, + 0x003d_1089, + 0x0015_b10f, + 0x001b_b09d, + 0x0028_100d, + 0x0037_11a5, + 0x000e_f061, + 0x0017_f083, + 0x0032_b191, + 0x0028_71af, + 0x004b_d14b, + 0x0015_b08b, + 0x0013_d03d, + 0x0020_b1df, + 0x000a_7005, + 0x001d_f0e9, + 0x002e_f175, + 0x0011_900d, + 0x0013_d10f, + 0x000b_f01f, + 0x0028_7239, + 0x000a_d0a3, + 0x0011_903b, + 0x0035_51f3, + 0x000e_f029, + 0x0009_5003, + 0x0009_d025, + 0x0033_d0ef, + 0x003e_5337, + 0x0013_70f1, + 0x001b_b01d, + 0x0025_1035, + 0x000c_7061, + 0x0006_b01f, + 0x0008_3013, + 0x001c_d10f, + 0x000e_f0a3, + 0x0011_b0c7, + 0x0026_9043, + 0x002e_72a5, + 0x0075_1445, + 0x002e_7223, + 0x003f_1251, + 0x0003_d03b, + 0x0025_7175, + 0x0017_508b, + 0x0031_d17f, + 0x0038_f2cf, + 0x0015_b0a3, + 0x0010_f0c5, + 0x0048_b0c1, + 0x0010_f0e3, + 0x0003_5017, + 0x0030_5137, + 0x002a_b0bf, + 0x000b_f08b, + 0x0036_d0ef, + 0x000d_30ad, + 0x0005_3017, + 0x002a_1137, + 0x0019_10e9, + 0x001c_1199, + 0x000c_503d, + 0x000b_f067, + 0x0020_9175, + 0x001f_3083, + 0x004b_1449, + 0x0011_9043, + 0x001d_310f, + 0x0027_71d3, + 0x002e_70ad, + 0x002d_d083, + 0x0029_507f, + 0x0016_709d, + 0x0017_503d, + 0x001d_30fb, + 0x001f_70b3, + 0x0028_115d, + 0x0019_10a3, + 0x0002_501d, + 0x003c_b2d7, + 0x0021_d1a5, + 0x003d_715d, + 0x0015_d049, + 0x000d_3071, + 0x0023_b133, + 0x004a_3295, + 0x001a_f0b3, + 0x0031_d233, + 0x001c_9011, + 0x002d_d11b, + 0x003d_1025, + 0x001c_f1b1, + 0x003e_506b, + 0x000e_3095, + 0x000a_3053, + 0x0004_7043, + 0x0015_d0ad, + 0x0031_32c5, + 0x0013_309d, + 0x0011_b02f, + 0x001a_300d, + 0x0025_11af, + 0x0025_903b, + 0x0015_d011, + 0x0012_50e9, + 0x000b_f013, + 0x0010_10ad, + 0x0042_d2cf, + 0x0035_928d, + 0x0017_f13d, + 0x0015_10fb, + 0x0015_111b, + 0x0012_5047, + 0x000e_90c5, + 0x002f_901d, + 0x001a_3005, + 0x0022_d209, + 0x0005_902f, + 0x002a_50c7, + 0x0033_b03d, + 0x001c_f0ef, + 0x0022_30bf, + 0x0013_30e3, + 0x0049_3251, + 0x000b_5067, + 0x005f_b4cd, + 0x0019_10df, + 0x0028_315b, + 0x000f_10e5, + 0x0016_f15b, + 0x0019_100d, + 0x0003_d013, + 0x001a_f059, + 0x0010_d0b5, + 0x000e_9065, + 0x0026_9151, + 0x000c_504f, + 0x0028_d0c1, + 0x003a_d329, + 0x0017_f005, + 0x0014_b101, + 0x0017_b107, + 0x0011_503d, + 0x0047_f33b, + 0x0006_b029, + 0x0017_5133, + 0x001f_d0e5, + 0x001b_1151, + 0x000a_d049, + 0x003f_1089, + 0x0011_506d, + 0x0024_b1cd, + 0x0011_9061, + 0x0031_d02f, + 0x0025_f03d, + 0x0004_3011, + 0x002a_516f, + 0x001c_d005, + 0x003a_9265, + 0x0016_7059, + 0x0016_f167, + 0x000c_502b, + 0x0022_300d, + 0x000c_5017, + 0x0032_b265, + 0x0013_907f, + 0x0005_3029, + 0x0019_115d, + 0x0015_b02f, + 0x0033_728d, + 0x001d_3185, + 0x0029_3223, + 0x0010_702f, + 0x001f_3005, + 0x001c_91c1, + 0x0011_b0e5, + 0x005d_116f, + 0x000e_906b, + 0x0016_f065, + 0x0024_10fb, + 0x0011_909d, + 0x0019_100d, + 0x002a_106b, + 0x0006_b047, + 0x0006_d005, + 0x000d_f02f, + 0x0029_51b7, + 0x004c_7035, + 0x002e_717b, + 0x0037_10c5, + 0x0015_b03b, + 0x001d_310d, + 0x001e_b151, + 0x0006_5005, + 0x001f_302b, + 0x0020_9097, + 0x000e_30b3, + 0x0015_1065, + 0x0029_5257, + 0x001b_7005, + 0x0013_902b, + 0x0011_90c1, + 0x0044_33f1, + 0x0029_3125, + 0x0037_10c1, + 0x0010_d0c5, + 0x0028_d003, + 0x000b_3025, + 0x0035_f25f, + 0x0011_b00d, + 0x000e_5017, + 0x0001_100d, + 0x0025_1133, + 0x0008_b07f, + 0x000b_303d, + 0x000a_d007, + 0x0009_7029, + 0x000c_102b, + 0x0006_b02b, + 0x0028_1209, + 0x0032_9265, + 0x0031_d029, + 0x0009_7095, + 0x000b_5017, + 0x0022_d0c1, + 0x0018_d06b, + 0x0016_7071, + 0x0035_f2b3, + 0x0010_d007, + 0x0024_10a3, + 0x0010_f061, + 0x0006_500d, + 0x001e_710f, + 0x001c_d107, + 0x0019_1137, + 0x003b_935b, + 0x0057_7175, + 0x0013_d0e3, + 0x0009_5089, + 0x0019_9071, + 0x0025_90b3, + 0x0006_d017, + 0x005c_f067, + 0x0001_d013, + 0x001a_f0b5, + 0x0025_9011, + 0x000e_509d, + 0x0025_f16f, + 0x0013_9107, + 0x002d_716f, + 0x000e_50d3, + 0x0011_902b, + 0x0027_7257, + 0x0014_b047, + 0x000c_1095, + 0x000d_3011, + 0x000d_f0d3, + 0x001b_7061, + 0x0006_b04f, + 0x001c_f14b, + 0x0027_70bf, + 0x0049_d281, + 0x003d_11a5, + 0x0010_d0df, + 0x0016_1029, + 0x0010_70a7, + 0x000e_900b, + 0x0055_7277, + 0x0040_93f1, + 0x001f_311b, + 0x0074_541b, + 0x0043_f1eb, + 0x0006_702b, + 0x001f_703b, + 0x0018_d0e9, + 0x0009_702b, + 0x000f_10ad, + 0x002a_128d, + 0x0013_d00b, + 0x001c_9025, + 0x0020_b11b, + 0x002e_7277, + 0x0013_d0ad, + 0x0019_1005, + 0x001e_7185, + 0x0013_d003, + 0x0018_5059, + 0x002b_318d, + 0x0011_b0c7, + 0x0022_d0ef, + 0x000a_d049, + 0x005c_9223, + 0x0036_d095, + 0x0017_b10d, + 0x0015_b03b, + 0x0033_b043, + 0x004c_700d, + 0x0028_11fd, + 0x0006_503d, + 0x0013_d013, + 0x001d_3035, + 0x0038_b0c1, + 0x0024_b1e7, + 0x000b_f00b, + 0x001e_70c5, + 0x001b_b071, + 0x000e_3059, + 0x000b_f083, + 0x0015_d107, + 0x001f_d1f7, + 0x001c_d119, + 0x0021_d0bf, + 0x001c_9191, + 0x001c_10b5, + 0x0016_f107, + 0x005e_7377, + 0x0017_b107, + 0x001a_3083, + 0x000a_700d, + 0x0013_3053, + 0x0003_500d, + 0x0026_90c5, + 0x0028_7167, + 0x000f_106d, + 0x0010_10e9, + 0x0024_11b1, + 0x001c_9025, + 0x0016_115b, + 0x0018_d17f, + 0x0018_d061, + 0x000d_300d, + 0x0022_d137, + 0x0024_b053, + 0x0011_908b, + 0x0035_52ab, + 0x0008_904f, + 0x0008_3047, + 0x0028_120b, + 0x0011_9053, + 0x0035_533b, + 0x0012_50c1, + 0x001c_903b, + 0x000e_9005, + 0x000e_50c5, + 0x0035_b1a5, + 0x001b_b00d, + 0x0013_7047, + 0x002b_3115, + 0x0008_3059, + 0x001f_d029, + 0x000f_1005, + 0x0012_5013, + 0x001b_1011, + 0x001f_3175, + 0x001a_f011, + 0x0008_9011, + 0x0035_f1a3, + 0x000f_b011, + 0x0019_90c1, + 0x0010_d0c5, + 0x0023_9025, + 0x0016_7095, + 0x0013_3119, + 0x0015_b00d, + 0x0033_7065, + 0x0023_30e9, + 0x0006_7035, + 0x0000_d003, + 0x003b_3337, + 0x0033_5133, + 0x001a_f151, + 0x001b_10e3, + 0x0013_9083, + 0x001c_9025, + 0x0023_30df, + 0x000b_3005, + 0x001f_d08b, + 0x0027_71b7, + 0x002c_51f7, + 0x000a_7049, + 0x001d_31c1, + 0x000a_d061, + 0x0013_d035, + 0x001e_b035, + 0x0023_30a7, + 0x0007_f02b, + 0x0012_50a3, + 0x0035_f1c9, + 0x0042_5095, + 0x001d_31c1, + 0x0019_9133, + 0x001f_700d, + 0x000e_50c5, + 0x001a_f049, + 0x001a_508b, + 0x002d_d01f, + 0x0019_10c1, + 0x0022_d0ef, + 0x0025_7101, + 0x0028_3101, + 0x000c_7065, + 0x000d_f017, + 0x0030_51cf, + 0x0025_70c5, + 0x0013_901d, + 0x0009_d035, + 0x0035_9005, + 0x0003_b00b, + 0x0015_d0e9, + 0x0017_b03b, + 0x002c_5295, + 0x0050_b1e7, + 0x001a_30d3, + 0x000e_303b, + 0x0026_507f, + 0x000b_3005, + 0x0031_31a5, + 0x003b_933d, + 0x0018_d00d, + 0x0004_901f, + 0x001b_10c1, + 0x0006_100d, + 0x0033_523b, + 0x000e_306d, + 0x002a_113d, + 0x000f_b0c7, + 0x0001_100d, + 0x0030_1269, + 0x0026_b14b, + 0x000e_f00d, + 0x000c_5049, + 0x0029_50f1, + 0x0037_31df, + 0x002d_71e7, + 0x0017_5097, + 0x001c_1191, + 0x0019_1047, + 0x0004_301d, + 0x0037_3035, + 0x0008_b017, + 0x000b_5061, + 0x0055_10ef, + 0x0006_103b, + 0x0024_11f7, + 0x0011_5029, + 0x006a_d655, + 0x0028_d065, + 0x0006_104f, + 0x001a_5083, + 0x0003_d035, + 0x0023_906d, + 0x001f_717b, + 0x002b_d265, + 0x001d_31cd, + 0x003f_50c7, + 0x000d_f007, + 0x004c_1377, + 0x0018_d0f1, + 0x0042_d01f, + 0x003c_703d, + 0x002a_506d, + 0x006c_538b, + 0x0002_b029, + 0x0006_d00d, + 0x000b_301f, + 0x0035_90f1, + 0x0049_3133, + 0x0028_31d3, + 0x0009_d01f, + 0x0028_d191, + 0x0030_10ef, + 0x001f_d10d, + 0x000b_503b, + 0x000a_d071, + 0x0013_306b, + 0x002e_70e5, + 0x0009_d02f, + 0x0029_31c9, + 0x0009_7035, + 0x0002_b013, + 0x0026_5223, + 0x0011_502b, + 0x0046_940f, + 0x0009_d01d, + 0x0031_30c1, + 0x000b_5013, + 0x003a_1293, + 0x0016_7137, + 0x002a_b15d, + 0x0015_1035, + 0x002a_b02b, + 0x0033_703b, + 0x0026_5017, + 0x0011_5003, + 0x001d_f133, + 0x000e_5005, + 0x000e_901d, + 0x0048_b049, + 0x0043_f283, + 0x000d_f025, + 0x0005_9025, + 0x0011_50a3, + 0x000e_9017, + 0x0012_500d, + 0x0022_31a3, + 0x003f_b281, + 0x0001_d013, + 0x0044_5281, + 0x0010_f0b3, + 0x002a_1007, + 0x0010_d0ef, + 0x0018_d0ad, + 0x0007_102f, + 0x000c_7089, + 0x002d_d1bb, + 0x0047_f0df, + 0x0026_50b5, + 0x0029_316f, + 0x005b_f133, + 0x0013_30c1, + 0x0017_b017, + 0x0006_b01f, + 0x0056_5233, + 0x001d_f01f, + 0x0001_f01d, + 0x000a_702f, + 0x000b_506d, + 0x0039_703b, + 0x0023_900d, + 0x0034_7233, + 0x0014_b0e3, + 0x0010_d005, + 0x003f_d1f7, + 0x0006_702b, + 0x000d_f097, + 0x0017_b0e5, + 0x003a_d18d, + 0x001c_d053, + 0x0027_71a5, + 0x0008_b061, + 0x0017_5083, + 0x0011_9097, + 0x0023_3101, + 0x0018_511b, + 0x000e_3035, + 0x000e_5043, + 0x001d_f1b1, + 0x0013_3061, + 0x0033_b2b3, + 0x0042_d2a5, + 0x0002_f02b, + 0x0026_5115, + 0x0016_f067, + 0x0004_303d, + 0x002f_91b7, + 0x002a_11b1, + 0x0011_903b, + 0x001c_f02b, + 0x003f_5053, + 0x0006_d035, + 0x001c_102f, + 0x0014_b013, + 0x0017_f095, + 0x000e_90a3, + 0x001f_d011, + 0x0015_d101, + 0x0029_515b, + 0x004c_7305, + 0x0008_3005, + 0x002a_b13d, + 0x0015_b04f, + 0x0018_5161, + 0x0019_90c7, + 0x0008_901d, + 0x0058_f2c5, + 0x0026_b199, + 0x0033_d083, + 0x0026_5049, + 0x001c_f191, + 0x002a_10f1, + 0x001e_b0c1, + 0x0032_b04f, + 0x0008_301d, + 0x001c_9083, + 0x001f_30e3, + 0x000c_10bf, + 0x0015_d0d3, + 0x0017_b0b5, + 0x0012_503d, + 0x001f_30b5, + 0x000f_b09d, + 0x0033_500b, + 0x001a_3043, + 0x0020_b067, + 0x003d_f007, + 0x002f_51e7, + 0x0017_f14b, + 0x006f_b515, + 0x0022_3017, + 0x000d_307f, + 0x0023_3017, + 0x0020_b0bf, + 0x0017_b0bf, + 0x0006_503d, + 0x003c_b101, + 0x0035_b0c1, + 0x002e_717b, + 0x0018_5133, + 0x0019_10f1, + 0x003f_5013, + 0x0013_d035, + 0x0009_d06b, + 0x0040_70bf, + 0x0019_100d, + 0x0030_12dd, + 0x0020_b0df, + 0x0017_506d, + 0x002e_701d, + 0x000e_300d, + 0x0031_d01f, + 0x0016_10a7, + 0x000d_303d, + 0x0018_5053, + 0x0006_700d, + 0x0014_b013, + 0x0017_f15b, + 0x0017_5125, + 0x0036_d0c7, + 0x0022_3013, + 0x0018_5083, + 0x0017_f107, + 0x0011_b005, + 0x001b_b1a5, + 0x001a_f02f, + 0x0010_d0a7, + 0x0003_501d, + 0x000d_306d, + 0x003c_72e7, + 0x000f_10b3, + 0x0013_709d, + 0x0029_31b1, + 0x0007_1067, + 0x001c_1125, + 0x0006_103d, + 0x000b_5029, + 0x0025_f1b1, + 0x0035_5043, + 0x0008_b053, + 0x0010_7003, + 0x0004_700d, + 0x002b_308b, + 0x001a_f175, + 0x0010_d061, + 0x0023_9005, + 0x001a_5013, + 0x000d_3089, + 0x0007_f047, + 0x002a_5259, + 0x002e_f13d, + 0x0028_d11b, + 0x0013_703d, + 0x000b_30a3, + 0x001b_716f, + 0x001a_306d, + 0x0006_b00b, + 0x001e_b065, + 0x0020_b1d3, + 0x001a_3035, + 0x0033_7047, + 0x0011_90ef, + 0x0008_904f, + 0x0006_d02b, + 0x0015_102b, + 0x0019_107f, + 0x000a_7083, + 0x0015_d005, + 0x0032_b2a1, + 0x0005_3047, + 0x0013_9137, + 0x0028_3025, + 0x001c_d17b, + 0x0016_f101, + 0x0013_901f, + 0x0035_f1eb, + 0x001a_30c5, + 0x0023_906d, + 0x0030_51a3, + 0x0015_d0c1, + 0x0013_3025, + 0x0023_3097, + 0x0032_b0b3, + 0x0059_f199, + 0x000b_f083, + 0x000a_702b, + 0x0006_704f, + 0x0004_f005, + 0x0006_5035, + 0x0022_d0ef, + 0x0008_b011, + 0x000e_3095, + 0x0022_d1c1, + 0x000b_308b, + 0x001e_7097, + 0x0021_d01f, + 0x0019_1005, + 0x002e_f10f, + 0x0009_7035, + 0x0035_923b, + 0x000b_f047, + 0x000b_f049, + 0x0017_503b, + 0x0045_5373, + 0x002e_326b, + 0x003e_5047, + 0x0011_9005, + 0x0010_7071, + 0x0014_b035, + 0x0006_503d, + 0x000f_b0ef, + 0x0015_b0f1, + 0x001d_f08b, + 0x0016_702f, + 0x0013_d047, + 0x0040_73a9, + 0x0001_300b, + 0x001c_117f, + 0x001b_1029, + 0x002f_90e5, + 0x0026_51b7, + 0x0012_508b, + 0x0003_b02b, + 0x0016_f005, + 0x0009_700d, + 0x000b_5017, + 0x0015_d06d, + 0x0028_3025, + 0x0020_b1df, + 0x000e_90bf, + 0x0008_b059, + 0x001c_902b, + 0x0006_5025, + 0x0008_306d, + 0x000d_30b5, + 0x0033_71eb, + 0x001d_f133, + 0x001d_f02b, + 0x0044_32ab, + 0x0025_f08b, + 0x002c_f089, + 0x000e_306d, + 0x001c_908b, + 0x0025_9233, + 0x0005_9005, + 0x000c_1067, + 0x0029_50ef, + 0x0039_70ef, + 0x0046_90d3, + 0x000c_706b, + 0x0024_10fb, + 0x0013_7005, + 0x0024_10e5, + 0x0017_50e5, + 0x0015_100d, + 0x0021_d1b1, + 0x001d_3107, + 0x0010_101f, + 0x003c_71fd, + 0x0016_1107, + 0x0013_7029, + 0x001a_f185, + 0x0003_d011, + 0x003f_1301, + 0x0022_d0a3, + 0x000e_f06d, + 0x002c_f17f, + 0x0021_d08b, + 0x0022_30b5, + 0x000f_b097, + 0x0016_f053, + 0x001a_5095, + 0x0023_91f3, + 0x002d_d18d, + 0x0010_d08b, + 0x0010_108b, + 0x0048_1013, + 0x000b_5029, + 0x0006_1047, + 0x0021_d089, + 0x0015_107f, + 0x0007_103d, + 0x0039_735f, + 0x0010_d0a3, + 0x001e_7071, + 0x001c_f0c7, + 0x0005_3047, + 0x0001_100d, + 0x0013_9005, + 0x000b_f00b, + 0x001b_1101, + 0x0037_306d, + 0x002a_b0df, + 0x0024_10bf, + 0x0013_7083, + 0x0039_72c5, + 0x0016_f0e9, + 0x002f_51bb, + 0x0033_71b7, + 0x002e_72d7, + 0x001d_f151, + 0x000f_b0a7, + 0x0029_5107, + 0x001a_f125, + 0x001f_315d, + 0x000a_702f, + 0x0019_1119, + 0x0037_7371, + 0x0015_10fb, + 0x001c_101f, + 0x0046_90b5, + 0x0009_d013, + 0x0025_f035, + 0x001a_3029, + 0x0016_100b, + 0x0020_910f, + 0x003c_724b, + 0x0008_3053, + 0x001b_b09d, + 0x002d_d17f, + 0x003e_5347, + 0x0019_10f1, + 0x000f_b005, + 0x0010_7097, + 0x0011_9005, + 0x0004_f049, + 0x0008_3011, + 0x0006_d02f, + 0x0010_d06b, + 0x001b_1185, + 0x001a_501d, + 0x001c_d0c1, + 0x001b_b08b, + 0x0016_f0d3, + 0x002c_f067, + 0x0013_d00d, + 0x0013_301f, + 0x0017_f005, + 0x0010_1083, + 0x001b_b01d, + 0x002c_508b, + 0x0016_10e3, + 0x0013_70bf, + 0x0049_31af, + 0x000e_f07f, + 0x0011_b049, + 0x0006_7013, + 0x0008_306d, + 0x002a_1043, + 0x0006_5059, + 0x000c_5089, + 0x0011_5067, + 0x0035_b01f, + 0x001d_f191, + 0x0025_9107, + 0x001b_7011, + 0x002c_f13d, + 0x0031_3011, + 0x0024_b003, + 0x0021_d065, + 0x000f_1061, + 0x0011_b0e9, + 0x0010_70c5, + 0x0023_3209, + 0x0005_9005, + 0x003a_1005, + 0x0021_d17b, + 0x001a_310d, + 0x0019_118d, + 0x002b_d005, + 0x001c_d061, + 0x0011_50fb, + 0x0010_70a3, + 0x001b_7139, + 0x0016_f15d, + 0x001e_b133, + 0x0033_d0fb, + 0x000b_302b, + 0x0013_3071, + 0x0030_51c1, + 0x000b_3061, + 0x0017_500d, + 0x0011_90c7, + 0x0009_700d, + 0x001a_314b, + 0x0036_d1cf, + 0x000f_b0b3, + 0x0022_3199, + 0x0013_d017, + 0x0015_b09d, + 0x001d_f00d, + 0x0004_f035, + 0x0037_126b, + 0x0031_316f, + 0x0015_b029, + 0x0011_b065, + 0x0040_72c5, + 0x0009_7065, + 0x001a_3175, + 0x0009_5083, + 0x0016_f0b3, + 0x000e_5061, + 0x001c_115b, + 0x0015_d011, + 0x001f_3139, + 0x0035_b257, + 0x0004_3005, + 0x0016_710d, + 0x000f_101f, + 0x0009_506d, + 0x0044_522d, + 0x0002_9025, + 0x001f_7005, + 0x0022_31e7, + 0x0018_507f, + 0x0015_d005, + 0x0011_902b, + 0x0017_5059, + 0x002b_d005, + 0x002b_32a1, + 0x0035_f13d, + 0x0012_50bf, + 0x0027_7241, + 0x000c_50b3, + 0x0026_90b3, + 0x0015_1043, + 0x000f_b02b, + 0x0026_5061, + 0x000f_107f, + 0x001c_f14b, + 0x000a_d089, + 0x000c_100d, + 0x0008_9061, + 0x0019_906d, + 0x0010_d107, + 0x0001_1003, + 0x0020_9029, + 0x002c_5295, + 0x0024_b14b, + 0x00aa_99c7, + 0x0006_700b, + 0x0016_103d, + 0x0004_9005, + 0x0018_d119, + 0x000e_9061, + 0x0042_53d7, + 0x0014_b02b, + 0x0017_f013, + 0x0038_f2ef, + 0x002c_f0a7, + 0x0003_b025, + 0x003f_116f, + 0x001e_70ad, + 0x0013_706d, + 0x0059_f269, + 0x0011_b011, + 0x000c_10b5, + 0x0016_f089, + 0x002c_5161, + 0x000c_503d, + 0x0014_b0c7, + 0x0002_5017, + 0x001f_d1b7, + 0x0009_7061, + 0x001b_b11b, + 0x0006_5005, + 0x0013_9137, + 0x001b_103b, + 0x0028_3017, + 0x0015_b00d, + 0x0014_b0c5, + 0x000c_700d, + 0x0015_b02b, + 0x0013_d013, + 0x001f_700d, + 0x0023_902b, + 0x000a_701d, + 0x0033_51f7, + 0x0029_30c7, + 0x0024_b241, + 0x001b_104f, + 0x0028_70e3, + 0x001d_3011, + 0x000c_709d, + 0x001e_71d3, + 0x0025_71f7, + 0x0010_f03d, + 0x001b_110f, + 0x004a_90c5, + 0x005a_d557, + 0x0007_100d, + 0x002b_30df, + 0x002b_300d, + 0x0040_925f, + 0x000e_90c1, + 0x003f_b32b, + 0x0013_30e5, + 0x0040_9251, + 0x0014_b137, + 0x0008_3035, + 0x000c_7017, + 0x0000_5003, + 0x0013_9065, + 0x002b_d02f, + 0x0011_5029, + 0x0031_30c7, + 0x000c_1013, + 0x002d_72a5, + 0x0008_b06b, + 0x0013_d0e5, + 0x0010_7013, + 0x0011_b0fb, + 0x0074_b005, + 0x001e_b06d, + 0x0026_910d, + 0x0010_7047, + 0x002b_d00d, + 0x0035_f2ef, + 0x002e_7125, + 0x0008_b06d, + 0x0019_10c7, + 0x0011_902b, + 0x0010_f00d, + 0x0003_d025, + 0x002c_5053, + 0x0006_d03b, + 0x0011_b01f, + 0x0015_100d, + 0x0025_91a3, + 0x0015_102b, + 0x000b_f017, + 0x0013_910d, + 0x0019_9067, + 0x0021_d06d, + 0x0009_506b, + 0x0019_1175, + 0x001a_50e9, + 0x0009_d029, + 0x0004_703d, + 0x0026_b11b, + 0x0004_701d, + 0x0022_d00d, + 0x004c_d071, + 0x000e_909d, + 0x001a_f16f, + 0x0038_f095, + 0x001e_b005, + 0x000a_306d, + 0x0013_9101, + 0x001c_f043, + 0x0005_9029, + 0x0003_d017, + 0x001e_70f1, + 0x001e_706b, + 0x0011_b017, + 0x0016_70b3, + 0x000f_10c1, + 0x0008_300d, + 0x004a_947f, + 0x0023_310f, + 0x0005_3017, + 0x001d_315b, + 0x0010_d011, + 0x0077_32cf, + 0x0008_3049, + 0x0046_900b, + 0x0028_7269, + 0x0006_5007, + 0x0028_716f, + 0x0047_f025, + 0x0039_7347, + 0x0033_71b1, + 0x0023_900b, + 0x000c_500d, + 0x002f_5281, + 0x0024_11b7, + 0x001a_f0d3, + 0x000b_f06b, + 0x0038_f08b, + 0x0003_d007, + 0x003c_7223, + 0x0017_b119, + 0x005a_74eb, + 0x000d_30b3, + 0x002e_326b, + 0x001f_31cd, + 0x000b_500d, + 0x0015_b06d, + 0x0023_b1af, + 0x001a_301f, + 0x001a_f0c5, + 0x0033_5313, + 0x001c_90c7, + 0x0036_d025, + 0x003a_900d, + 0x002f_9089, + 0x001b_1065, + 0x000a_d07f, + 0x0025_9007, + 0x000e_f089, + 0x0046_900d, + 0x0011_90ef, + 0x001a_5013, + 0x000c_1065, + 0x0011_9071, + 0x001b_70a3, + 0x0037_7191, + 0x0032_b0bf, + 0x0022_d1a3, + 0x0028_d223, + 0x0010_d00d, + 0x0017_b00b, + 0x0026_5025, + 0x0046_9029, + 0x0015_d13d, + 0x0056_5101, + 0x0003_502f, + 0x0013_90ad, + 0x0010_1065, + 0x001b_b119, + 0x0011_b0b3, + 0x002f_508b, + 0x0030_5017, + 0x001c_1025, + 0x001d_f0fb, + 0x0060_d06b, + 0x0058_f1a5, + 0x0009_7053, + 0x0017_5029, + 0x0003_b025, + 0x0028_d1df, + 0x002c_f1e7, + 0x0016_f06b, + 0x0023_9061, + 0x0057_71df, + 0x0023_b10f, + 0x0050_33c7, + 0x000c_5067, + 0x002a_52a1, + 0x0013_3025, + 0x0009_d02f, + 0x0037_30d3, + 0x0033_d00d, + 0x0007_f011, + 0x0010_d0d3, + 0x0018_d00d, + 0x0017_510f, + 0x001b_10a7, + 0x0012_50e5, + 0x0012_50d3, + 0x000b_f005, + 0x0014_b03d, + 0x0037_331d, + 0x0025_91cf, + 0x001d_f0c7, + 0x0041_917f, + 0x0046_9359, + 0x0017_50ef, + 0x0050_b3a9, + 0x005f_b4e1, + 0x000c_7029, + 0x002a_108b, + 0x002d_7167, + 0x001d_f199, + 0x0010_f0ad, + 0x0014_b119, + 0x001f_d191, + 0x001f_31a3, + 0x0004_303d, + 0x0031_d00d, + 0x0024_1209, + 0x0009_d00d, + 0x0024_b00d, + 0x001c_1049, + 0x001b_b01d, + 0x0030_1005, + 0x0029_320b, + 0x0018_515d, + 0x0007_101d, + 0x0033_b257, + 0x0010_70f1, + 0x0010_f053, + 0x0013_30b5, + 0x0011_b083, + 0x0017_f065, + 0x0004_f00b, + 0x0010_f0ef, + 0x000b_50ad, + 0x0035_b125, + 0x0009_701d, + 0x0008_303d, + 0x0011_501f, + 0x0051_b305, + 0x0062_b407, + 0x001b_7199, + 0x002c_51fd, + 0x0058_1241, + 0x002d_d15b, + 0x0002_5013, + 0x0010_d00b, + 0x001c_d0b3, + 0x000c_50b3, + 0x002f_50df, + 0x0064_d1df, + 0x001c_d161, + 0x0011_5005, + 0x001b_b18d, + 0x0003_5005, + 0x0010_1083, + 0x001e_70a3, + 0x0030_504f, + 0x000e_5083, + 0x000b_f06b, + 0x0013_9061, + 0x002b_3049, + 0x000c_5065, + 0x0049_d481, + 0x000f_1005, + 0x004c_704f, + 0x0007_102b, + 0x0019_1125, + 0x000d_f047, + 0x000a_3095, + 0x0030_11bb, + 0x002b_318d, + 0x003d_711b, + 0x0022_310f, + 0x0028_1003, + 0x0015_b0e3, + 0x002b_d053, + 0x002d_72a1, + 0x000a_303b, + 0x002e_32dd, + 0x0025_7239, + 0x0011_b059, + 0x000b_50a3, + 0x001f_7025, + 0x0023_908b, + 0x0015_1139, + 0x0020_906d, + 0x0023_b0f1, + 0x0040_f095, + 0x000c_50a3, + 0x0008_b01f, + 0x000a_d083, + 0x000f_b065, + 0x004e_142d, + 0x0024_101d, + 0x000b_5005, + 0x0060_d24b, + 0x001a_3047, + 0x0040_f283, + 0x0028_326b, + 0x0010_d03b, + 0x0059_5409, + 0x0013_3065, + 0x001f_d0b5, + 0x0035_9065, + 0x0020_91af, + 0x000c_10bf, + 0x000b_f049, + 0x002c_f287, + 0x0013_700d, + 0x0017_b0d3, + 0x004b_d017, + 0x002c_5083, + 0x002d_d1c1, + 0x0016_f04f, + 0x001e_7089, + 0x0026_51a3, + 0x0010_7011, + 0x0003_5011, + 0x0073_7493, + 0x0031_d2bd, + 0x0025_7223, + 0x0020_91a5, + 0x0050_343f, + 0x0024_100d, + 0x0018_d0c5, + 0x0002_b025, + 0x0016_f0b5, + 0x000a_d03d, + 0x0013_70ad, + 0x001f_d15b, + 0x002e_706d, + 0x0016_f017, + 0x0009_7053, + 0x0007_1029, + 0x0005_9047, + 0x000c_10ad, + 0x0023_91b1, + 0x003f_117f, + 0x001f_306b, + 0x0014_b133, + 0x0022_3133, + 0x0028_d0ad, + 0x001c_9003, + 0x0013_9043, + 0x001a_5185, + 0x0009_702b, + 0x0002_5005, + 0x003a_9305, + 0x0002_f00d, + 0x0026_9125, + 0x0018_d17b, + 0x002a_503b, + 0x0010_704f, + 0x0040_900d, + 0x002c_f11b, + 0x0011_9101, + 0x001f_31d3, + 0x0035_90df, + 0x004c_73df, + 0x001d_f17b, + 0x0010_d00d, + 0x0015_d02b, + 0x0022_d095, + 0x0011_900d, + 0x000e_302b, + 0x000e_302f, + 0x0006_7059, + 0x002c_f1f7, + 0x001c_f13d, + 0x0024_114b, + 0x0013_9083, + 0x0016_7151, + 0x0020_9011, + 0x0003_b025, + 0x0025_1175, + 0x0019_9185, + 0x0004_f00d, + 0x001a_5071, + 0x000f_b0c7, + 0x0029_328d, + 0x0008_306d, + 0x001d_3199, + 0x0004_f017, + 0x0039_72ef, + 0x0025_901f, + 0x0015_d0e5, + 0x001d_f0d3, + 0x0049_d119, + 0x003b_3089, + 0x000e_90d3, + 0x0001_f00b, + 0x0013_9053, + 0x0025_709d, + 0x003c_7175, + 0x0011_90e3, + 0x000d_f061, + 0x0013_3005, + 0x0026_91f7, + 0x0022_3017, + 0x0002_f00d, + 0x0028_3007, + 0x0003_d005, + 0x0015_b0a7, + 0x0010_f107, + 0x001d_f1b7, + 0x0013_30a7, + 0x0004_f00d, + 0x0028_101f, + 0x002a_514b, + 0x001c_110d, + 0x0014_b035, + 0x001e_b16f, + 0x002e_f2cf, + 0x0006_500d, + 0x004c_d42d, + 0x0010_f003, + 0x000e_3083, + 0x0009_5017, + 0x000d_3097, + 0x0025_1025, + 0x0006_b005, + 0x000e_90ad, + 0x0033_d1b7, + 0x0016_f097, + 0x000e_3049, + 0x0017_b161, + 0x0032_9007, + 0x0006_100b, + 0x0011_b061, + 0x0026_9119, + 0x000f_1065, + 0x0008_b06b, + 0x001d_f01d, + 0x001d_31a5, + 0x0033_d15b, + 0x0015_d10f, + 0x0009_d035, + 0x001a_5035, + 0x001b_110f, + 0x000e_3049, + 0x0017_5095, + 0x0003_d013, + 0x001a_304f, + 0x0011_5011, + 0x0020_b17b, + 0x0049_30df, + 0x0025_91d3, + 0x000c_500d, + 0x001a_5161, + 0x0010_f067, + 0x002d_d265, + 0x003b_914b, + 0x001f_31c9, + 0x0002_f00d, + 0x004c_f2ef, + 0x0018_5175, + 0x0051_702b, + 0x0010_70df, + 0x0006_d013, + 0x0017_50df, + 0x0008_3013, + 0x002f_92ef, + 0x001a_3013, + 0x0012_5095, + 0x000a_d04f, + 0x0015_b0ad, + 0x0001_3005, + 0x0002_501f, + 0x0022_302b, + 0x0025_f01f, + 0x0017_5133, + 0x0004_901d, + 0x0028_3151, + 0x0010_103d, + 0x0033_d00d, + 0x003f_52bd, + 0x001c_1005, + 0x000e_f043, + 0x0037_1175, + 0x0033_5089, + 0x0006_103d, + 0x0015_d0a3, + 0x000a_7089, + 0x0015_1003, + 0x001a_3115, + 0x0022_d1cd, + 0x000c_1059, + 0x0033_72a1, + 0x004d_5283, + 0x0004_f02b, + 0x001d_f00d, + 0x0006_b01f, + 0x0021_d059, + 0x0036_d1b7, + 0x001e_b1a3, + 0x0002_901f, + 0x0035_9071, + 0x0037_706b, + 0x0009_5053, + 0x0075_56c5, + 0x0012_510f, + 0x000f_b047, + 0x0009_7061, + 0x0026_b241, + 0x001b_70d3, + 0x0009_d007, + 0x0023_300d, + 0x0003_d01f, + 0x001c_10d3, + 0x003f_53cb, + 0x0023_3185, + 0x0019_900d, + 0x002a_5017, + 0x0018_d0b5, + 0x0028_d1bb, + 0x0006_7025, + 0x0016_7053, + 0x0008_9043, + 0x000d_f043, + 0x0040_f1fd, + 0x0018_5067, + 0x000a_70a3, + 0x0028_723b, + 0x001e_711b, + 0x0025_902b, + 0x0006_700d, + 0x0033_b175, + 0x000e_903b, + 0x002b_3017, + 0x0018_d04f, + 0x0009_d071, + 0x001b_1017, + 0x0013_d0ad, + 0x0022_d209, + 0x001c_9101, + 0x0022_31d3, + 0x0023_b233, + 0x002f_9281, + 0x000b_300b, + 0x0016_7095, + 0x0049_3481, + 0x000f_b02b, + 0x005d_52e7, + 0x001a_f07f, + 0x001d_3065, + 0x001c_903d, + 0x000f_b0a3, + 0x0020_9095, + 0x0044_942d, + 0x0004_700d, + 0x0025_701f, + 0x0037_306d, + 0x0016_103d, + 0x0025_70fb, + 0x0022_31c1, + 0x0008_906b, + 0x0014_b0b5, + 0x003d_1083, + 0x0021_d14b, + 0x0023_b1f7, + 0x0013_301d, + 0x0010_f005, + 0x0006_7017, + 0x000c_500d, + 0x001d_3067, + 0x0037_700b, + 0x0011_910d, + 0x002c_f277, + 0x000e_9059, + 0x000c_502b, + 0x0006_500d, + 0x0013_d061, + 0x0005_3049, + 0x000f_b0b5, + 0x0029_3107, + 0x000b_506d, + 0x0043_f2dd, + 0x002a_524b, + 0x003c_7151, + 0x0005_900d, + 0x0004_9011, + 0x000b_3005, + 0x000b_f0a3, + 0x001d_3137, + 0x0009_d07f, + 0x0032_9305, + 0x0010_7025, + 0x0042_7167, + 0x0015_101d, + 0x0029_517b, + 0x004a_910f, + 0x0023_b005, + 0x0006_b007, + 0x0009_5025, + 0x0010_10e9, + 0x0011_908b, + 0x000a_3017, + 0x001a_3101, + 0x003f_138f, + 0x0018_d14b, + 0x0011_50e9, + 0x0014_b0bf, + 0x0014_b035, + 0x0016_7119, + 0x000b_307f, + 0x001f_3167, + 0x000a_7065, + 0x0030_526b, + 0x0016_10e5, + 0x0022_3209, + 0x0037_1277, + 0x0016_f09d, + 0x0059_549d, + 0x0006_502f, + 0x0017_f0b5, + 0x0024_b047, + 0x0037_1089, + 0x0028_715d, + 0x0031_d0a7, + 0x0029_322d, + 0x002c_f2c5, + 0x000a_3043, + 0x000e_f007, + 0x001c_90ad, + 0x000e_300d, + 0x0018_5097, + 0x001a_f10d, + 0x002c_50a3, + 0x000b_5005, + 0x001a_310f, + 0x0005_300d, + 0x0006_102b, + 0x0004_7035, + 0x003f_d115, + 0x0009_700d, + 0x003d_12f9, + 0x0013_7017, + 0x0010_7097, + 0x000a_3065, + 0x002f_91af, + 0x0023_900d, + 0x000b_5097, + 0x0023_9035, + 0x0017_f061, + 0x0004_900d, + 0x000b_501d, + 0x001f_311b, + 0x001c_d14b, + 0x0051_1029, + 0x0018_d0c1, + 0x0008_b067, + 0x0029_520b, + 0x001a_50bf, + 0x0017_506b, + 0x001a_3151, + 0x001b_b1af, + 0x0028_313d, + 0x0019_1053, + 0x0028_d08b, + 0x0015_d003, + 0x0005_903d, + 0x0009_d013, + 0x0020_b095, + 0x000c_501f, + 0x002f_517b, + 0x0001_300d, + 0x000d_f07f, + 0x000e_308b, + 0x0059_9101, + 0x0008_9035, + 0x000d_f005, + 0x0019_115b, + 0x0025_7067, + 0x0044_f359, + 0x002a_5209, + 0x0068_32b3, + 0x005c_f0c7, + 0x0013_90c5, + 0x0004_301d, + 0x000b_309d, + 0x002c_f053, + 0x002a_b029, + 0x0049_d313, + 0x0038_b0d3, + 0x000d_f06b, + 0x000c_7053, + 0x0004_3025, + 0x0006_d059, + 0x0026_b161, + 0x000f_b005, + 0x0031_d115, + 0x0019_910f, + 0x0040_f035, + 0x0017_b09d, + 0x0006_501d, + 0x0028_7119, + 0x001a_f101, + 0x000a_708b, + 0x0031_d1fd, + 0x0025_f15b, + 0x000f_10c1, + 0x0008_b005, + 0x001f_3185, + 0x005c_f3ad, + 0x0009_d07f, + 0x0018_510d, + 0x0024_120b, + 0x0026_90c5, + 0x0024_1185, + 0x0028_11cf, + 0x0016_70c5, + 0x001a_5011, + 0x0022_3067, + 0x0011_b083, + 0x002d_d139, + 0x0018_5061, + 0x002b_3107, + 0x0023_b0a3, + 0x0028_710d, + 0x0025_9065, + 0x0001_d003, + 0x0028_30a3, + 0x0022_3083, + 0x0002_b029, + 0x001b_b059, + 0x0034_7301, + 0x0001_d005, + 0x0052_9251, + 0x000d_f025, + 0x0038_b347, + 0x0027_71af, + 0x001d_f1a5, + 0x000b_f049, + 0x0021_d0c1, + 0x0027_71df, + 0x0026_50f1, + 0x0028_3065, + 0x0004_9003, + 0x0005_9007, + 0x001a_508b, + 0x001e_71d3, + 0x0023_900d, + 0x0051_b1fd, + 0x0015_1035, + 0x000a_3005, + 0x000c_50bf, + 0x0013_d061, + 0x002b_d1af, + 0x0024_b0e3, + 0x000e_5047, + 0x000c_102b, + 0x0044_f0e5, + 0x0032_b22d, + 0x0012_501d, + 0x0023_31b1, + 0x001b_10bf, + 0x0004_7017, + 0x0026_913d, + 0x0006_500d, + 0x001e_7025, + 0x000c_506b, + 0x0016_107f, + 0x0024_118d, + 0x001b_b005, + 0x001c_9125, + 0x0018_510d, + 0x0020_b0ad, + 0x0013_30b3, + 0x004c_70a3, + 0x0018_50e3, + 0x001e_b00d, + 0x001a_3137, + 0x002a_111b, + 0x001e_701f, + 0x0028_31fd, + 0x0010_70e3, + 0x0006_5025, + 0x001d_f061, + 0x001c_1139, + 0x0023_b20b, + 0x0021_d17f, + 0x001b_1083, + 0x0013_d005, + 0x0010_70e5, + 0x001c_d09d, + 0x0025_9017, + 0x000b_f005, + 0x0015_10f1, + 0x0004_7013, + 0x0016_7017, + 0x0026_90ef, + 0x000b_5047, + 0x0013_9025, + 0x003c_b047, + 0x0014_b0d3, + 0x0027_71cf, + 0x001e_b0b5, + 0x001d_f025, + 0x0025_7241, + 0x0040_9239, + 0x001b_b0fb, + 0x0028_d00b, + 0x000a_7083, + 0x0004_7025, + 0x0021_d06b, + 0x002f_922d, + 0x001c_100b, + 0x001c_d1bb, + 0x0013_703b, + 0x001c_90c7, + 0x0059_51f3, + 0x000b_5005, + 0x003b_3269, + 0x002c_f28d, + 0x0031_d25f, + 0x0018_d0a3, + 0x000c_706b, + 0x0010_109d, + 0x002f_90d3, + 0x0009_503d, + 0x000b_500d, + 0x0028_700d, + 0x0015_d11b, + 0x0035_502f, + 0x0003_d035, + 0x0025_1043, + 0x0005_301f, + 0x0030_52a5, + 0x002b_d1af, + 0x0022_321d, + 0x0009_503d, + 0x0028_10c1, + 0x0013_706d, + 0x0005_9025, + 0x0033_501f, + 0x000d_307f, + 0x0009_d071, + 0x0079_f611, + 0x000c_702f, + 0x002f_9277, + 0x0022_301d, + 0x0004_303b, + 0x0000_b005, + 0x005b_f239, + 0x000a_d03b, + 0x0042_528d, + 0x0023_30c5, + 0x0061_150b, + 0x0028_113d, + 0x001b_716f, + 0x0004_f043, + 0x000a_300d, + 0x0007_1025, + 0x0008_9035, + 0x0012_501d, + 0x0031_323b, + 0x0038_f095, + 0x003c_b1c9, + 0x000f_b0d3, + 0x0020_91a5, + 0x0023_303d, + 0x001e_b067, + 0x0023_904f, + 0x0035_b043, + 0x000f_b0df, + 0x0015_d0c1, + 0x0013_30ef, + 0x0010_1017, + 0x001f_314b, + 0x0004_3005, + 0x0025_11f3, + 0x001d_300d, + 0x0002_b01f, + 0x000c_7053, + 0x0011_90df, + 0x002d_d1a3, + 0x0029_30c1, + 0x0013_70b3, + 0x0008_900b, + 0x0026_9059, + 0x000c_7017, + 0x003f_1011, + 0x0022_3107, + 0x0029_504f, + 0x0017_b005, + 0x002b_d25f, + 0x0008_3029, + 0x0020_b01d, + 0x001e_b00b, + 0x0034_7313, + 0x001b_110d, + 0x0010_7059, + 0x001b_70e9, + 0x0026_b269, + 0x0019_1119, + 0x0008_903d, + 0x0011_50e3, + 0x0023_9161, + 0x000d_f011, + 0x0020_b11b, + 0x0016_7047, + 0x0035_514b, + 0x000e_9059, + 0x000c_5029, + 0x0010_d0c1, + 0x0006_700d, + 0x0025_9017, + 0x0008_900d, + 0x001e_70fb, + 0x003c_b3b9, + 0x0011_b053, + 0x004c_f4c1, + 0x002c_5257, + 0x0037_110d, + 0x0009_d047, + 0x0011_510f, + 0x0023_b0f1, + 0x0046_9161, + 0x001f_303b, + 0x0018_506d, + 0x0014_b061, + 0x0027_717f, + 0x000e_3097, + 0x0008_9005, + 0x001c_110d, + 0x0027_7259, + 0x000b_50b3, + 0x000d_f097, + 0x0009_7071, + 0x0013_9071, + 0x000a_306d, + 0x001a_3119, + 0x0017_5095, + 0x0026_510d, + 0x000e_509d, + 0x0018_506b, + 0x000e_f06b, + 0x001b_10a3, + 0x000f_b059, + 0x0010_d047, + 0x000b_f00d, + 0x0013_908b, + 0x003a_100b, + 0x0020_90d3, + 0x0009_d095, + 0x000a_7049, + 0x0023_90ad, + 0x000e_900d, + 0x0035_b065, + 0x0013_7101, + 0x002e_30e3, + 0x0007_101f, + 0x001c_1097, + 0x0007_101f, + 0x0008_b083, + 0x003c_7049, + 0x000a_308b, + 0x0016_1049, + 0x0022_d053, + 0x003f_1259, + 0x0017_b047, + 0x0022_31df, + 0x0031_308b, + 0x0005_300b, + 0x0013_d071, + 0x0020_91a3, + 0x001f_d053, + 0x001c_1029, + 0x0013_7025, + 0x0042_d005, + 0x0020_91a5, + 0x0037_32b3, + 0x0008_3061, + 0x0022_d07f, + 0x0032_b10f, + 0x0017_b005, + 0x0009_7017, + 0x0029_3053, + 0x0049_347f, + 0x0033_72cf, + 0x000a_d049, + 0x0015_b095, + 0x0006_b005, + 0x0003_502b, + 0x0016_7083, + 0x001c_100b, + 0x000d_f03d, + 0x001c_904f, + 0x0008_3017, + 0x002e_71e7, + 0x000c_1011, + 0x001c_f0c7, + 0x001a_303d, + 0x002d_d251, + 0x0019_1151, + 0x0033_710f, + 0x0011_5095, + 0x0019_10b5, + 0x0023_b095, + 0x0023_3097, + 0x0028_d017, + 0x004c_d281, + 0x001f_d0c7, + 0x0032_9017, + 0x000a_7025, + 0x000b_306d, + 0x0037_72b3, + 0x0037_3011, + 0x000f_1043, + 0x002c_5251, + 0x0010_f06d, + 0x0026_902b, + 0x0009_5071, + 0x0012_5095, + 0x0018_d0e9, + 0x002a_50fb, + 0x001d_f0e3, + 0x000c_5025, + 0x0028_71b7, + 0x0029_5047, + 0x0018_5053, + 0x0055_10f1, + 0x0024_1115, + 0x0014_b03d, + 0x0024_b0a3, + 0x001e_71c1, + 0x0005_904f, + 0x0011_5059, + 0x0038_b005, + 0x0018_50e3, + 0x0013_d049, + 0x0001_f005, + 0x001d_30a7, + 0x0050_b32b, + 0x0012_5047, + 0x003c_71a3, + 0x001a_f071, + 0x000c_5005, + 0x0003_b00d, + 0x002e_f03b, + 0x004b_d0b5, + 0x0037_1089, + 0x0011_500d, + 0x0006_b01f, + 0x004a_92cf, + 0x0008_9071, + 0x000a_3007, + 0x0011_9043, + 0x003a_933b, + 0x0013_30ef, + 0x001b_b02f, + 0x000d_f005, + 0x001a_3167, + 0x000d_f0b5, + 0x0016_7011, + 0x002b_d00d, + 0x0012_5067, + 0x003f_5377, + 0x000e_909d, + 0x0004_900b, + 0x0011_b0df, + 0x0013_d0c1, + 0x0025_909d, + 0x0022_d1bb, + 0x000e_50a7, + 0x0010_d067, + 0x001a_f0b5, + 0x002f_5089, + 0x003b_3269, + 0x0040_710d, + 0x003b_3305, + 0x0015_1137, + 0x001a_506d, + 0x0018_513d, + 0x0022_d10d, + 0x0035_f175, + 0x002d_700d, + 0x0006_1013, + 0x0005_903d, + 0x0019_901d, + 0x001c_d0ef, + 0x0013_9065, + 0x0011_b04f, + 0x002a_500d, + 0x0055_1065, + 0x0028_324b, + 0x001f_d18d, + 0x0008_9083, + 0x002b_d139, + 0x000e_3053, + 0x0016_70e3, + 0x000e_50c1, + 0x0032_b2cf, + 0x000f_b0e9, + 0x0052_710f, + 0x0008_3029, + 0x004f_f335, + 0x0052_f1c9, + 0x000a_d04f, + 0x0017_b0b3, + 0x0020_b047, + 0x0035_52a1, + 0x000a_d097, + 0x0018_d095, + 0x0011_9089, + 0x002b_d1e7, + 0x001a_5071, + 0x0008_900d, + 0x000e_f017, + 0x0008_3043, + 0x0057_7059, + 0x0029_3265, + 0x0014_b0ef, + 0x001c_d175, + 0x0035_b101, + 0x0026_b15d, + 0x0010_70fb, + 0x003e_51d3, + 0x0008_9013, + 0x000b_3005, + 0x0028_d283, + 0x0024_1233, + 0x0039_7125, + 0x001d_3139, + 0x000e_f017, + 0x0015_b043, + 0x0011_b03d, + 0x0037_7287, + 0x0020_b199, + 0x001d_303b, + 0x001f_704f, + 0x0011_b03b, + 0x0023_917b, + 0x0028_3089, + 0x0002_900d, + 0x002f_9139, + 0x0004_7003, + 0x005d_5059, + 0x0011_50a7, + 0x0032_9283, + 0x0013_d035, + 0x0015_b08b, + 0x002c_5115, + 0x0010_d02f, + 0x000a_d0a3, + 0x0002_500d, + 0x0046_3223, + 0x0027_710f, + 0x0017_f151, + 0x0015_d151, + 0x001d_f161, + 0x0022_d083, + 0x003b_917f, + 0x0015_d101, + 0x0013_303b, + 0x0006_7049, + 0x000b_300b, + 0x0026_506d, + 0x001e_7071, + 0x001c_9139, + 0x0020_b089, + 0x0006_703b, + 0x001c_906b, + 0x001a_f115, + 0x0038_b2c5, + 0x0021_d0e3, + 0x0022_31e7, + 0x002e_704f, + 0x0030_502f, + 0x000b_f0a3, + 0x0051_13e5, + 0x0016_10e3, + 0x0027_7241, + 0x000c_1007, + 0x0019_1049, + 0x0020_90e5, + 0x001a_308b, + 0x001c_d133, + 0x003b_902b, + 0x0025_f137, + 0x0028_70b5, + 0x0017_b017, + 0x0020_91af, + 0x0011_90f1, + 0x0044_f0fb, + 0x001f_30a3, + 0x0033_5035, + 0x002b_d029, + 0x0008_300d, + 0x0019_117b, + 0x0006_7007, + 0x000f_b061, + 0x002f_911b, + 0x001a_5059, + 0x0029_306d, + 0x004a_3443, + 0x0038_f239, + 0x000c_70a7, + 0x001b_b005, + 0x0018_5125, + 0x000c_5035, + 0x0029_3133, + 0x001a_f0bf, + 0x0013_9043, + 0x0011_5017, + 0x0023_91e7, + 0x0011_b0f1, + 0x0023_3139, + 0x0032_b281, + 0x0004_3035, + 0x003e_5239, + 0x002e_7061, + 0x000f_b005, + 0x0025_f10d, + 0x0014_b01d, + 0x0030_503d, + 0x003f_5005, + 0x0038_f005, + 0x0032_91fd, + 0x0011_510d, + 0x0044_9281, + 0x0004_703b, + 0x0006_d017, + 0x0017_f03d, + 0x002a_51e7, + 0x0010_703b, + 0x0036_d15d, + 0x0033_d17f, + 0x001b_7133, + 0x0040_928d, + 0x001f_7017, + 0x000c_100d, + 0x001e_b017, + 0x0020_9161, + 0x0006_5049, + 0x0006_d025, + 0x003a_d185, + 0x001c_104f, + 0x000c_7047, + 0x001f_718d, + 0x0017_5133, + 0x0009_d013, + 0x0013_7065, + 0x0019_103d, + 0x001a_515b, + 0x000f_1065, + 0x0032_9049, + 0x000d_f011, + 0x001b_71af, + 0x0015_b0f1, + 0x0013_3125, + 0x0013_703d, + 0x002b_d175, + 0x0015_1119, + 0x0004_3011, + 0x001c_f125, + 0x0010_1029, + 0x001f_d04f, + 0x002f_90e3, + 0x005d_b107, + 0x0033_7175, + 0x0010_7095, + 0x0008_9035, + 0x0007_f003, + 0x000c_5035, + 0x000d_f0c5, + 0x003b_3371, + 0x0025_7047, + 0x0019_9185, + 0x001b_b095, + 0x0009_700d, + 0x0020_b1b1, + 0x0026_513d, + 0x0006_7061, + 0x001a_3053, + 0x0023_b017, + 0x0010_700d, + 0x0008_b049, + 0x001c_106d, + 0x0006_7025, + 0x0013_910f, + 0x0008_b053, + 0x0046_3359, + 0x0015_b101, + 0x0023_b08b, + 0x0018_d151, + 0x001e_710d, + 0x0027_7071, + 0x000f_b01d, + 0x002c_5257, + 0x000a_703d, + 0x0025_7101, + 0x001a_3035, + 0x000e_501d, + 0x0007_1059, + 0x001e_b005, + 0x0011_50e5, + 0x0025_f14b, + 0x0001_f00d, + 0x001f_d0df, + 0x0025_91d3, + 0x000e_301f, + 0x0028_70b3, + 0x0031_d06d, + 0x001b_b0a3, + 0x003c_717b, + 0x003f_d2f9, + 0x0013_710d, + 0x0003_d035, + 0x000b_f029, + 0x0016_f0bf, + 0x001a_50b3, + 0x0006_d017, + 0x0026_910f, + 0x0004_700d, + 0x001f_71eb, + 0x0015_b017, + 0x0017_5139, + 0x000f_b071, + 0x004f_d013, + 0x002e_f281, + 0x001b_b0ef, + 0x0016_f003, + 0x0012_5043, + 0x0023_31b1, + 0x0016_f10f, + 0x0011_9029, + 0x001c_90b5, + 0x001c_9119, + 0x0006_5061, + 0x0030_104f, + 0x001b_1047, + 0x001f_d14b, + 0x0005_3005, + 0x0008_b089, + 0x0031_30df, + 0x0009_5007, + 0x001b_b035, + 0x0024_b1f3, + 0x001e_71b1, + 0x0016_f03d, + 0x0010_d00d, + 0x0018_d03d, + 0x0031_d0c7, + 0x0025_71df, + 0x0033_71eb, + 0x0024_1095, + 0x0055_d061, + 0x0005_3013, + 0x0010_f043, + 0x0024_b13d, + 0x0009_5049, + 0x000d_f005, + 0x003a_9281, + 0x001f_71a5, + 0x001f_d00d, + 0x0004_7029, + 0x002d_71af, + 0x0028_d281, + 0x000d_f0bf, + 0x0011_500b, + 0x0020_9089, + 0x0020_b043, + 0x000e_f065, + 0x003b_3241, + 0x001d_30c5, + 0x0026_5191, + 0x0006_d02b, + 0x0025_90ef, + 0x000a_701d, + 0x000f_1067, + 0x0045_d1b7, + 0x001c_100d, + 0x001b_b029, + 0x0020_b00d, + 0x0008_3043, + 0x001a_f007, + 0x0041_b2cf, + 0x0028_d1fd, + 0x0008_b06d, + 0x0035_f00d, + 0x0026_b0e5, + 0x0004_3035, + 0x002a_503b, + 0x0010_10bf, + 0x0033_d1f7, + 0x0026_b107, + 0x003a_d005, + 0x0016_10bf, + 0x0031_d2ef, + 0x0004_f03d, + 0x002e_7101, + 0x0058_13b3, + 0x0014_b0b3, + 0x0010_f013, + 0x0018_5043, + 0x000e_309d, + 0x000d_f059, + 0x0031_307f, + 0x0038_f035, + 0x004e_1257, + 0x0021_d1af, + 0x001f_315b, + 0x000a_3059, + 0x0033_d2c5, + 0x004f_d02b, + 0x0017_502b, + 0x0028_110f, + 0x0023_3053, + 0x000f_b089, + 0x001b_700d, + 0x0010_f029, + 0x0044_52bd, + 0x002b_31cf, + 0x006f_1097, + 0x0028_1233, + 0x0022_d035, + 0x0019_90e3, + 0x0018_d025, + 0x003a_1049, + 0x0016_10df, + 0x002c_511b, + 0x0025_118d, + 0x002f_924b, + 0x0001_7013, + 0x0001_f00b, + 0x0004_300d, + 0x0015_b119, + 0x0018_d049, + 0x001a_504f, + 0x0023_b223, + 0x0026_910d, + 0x000a_d08b, + 0x000e_9067, + 0x0029_3013, + 0x0023_3059, + 0x0020_90f1, + 0x0026_b0a3, + 0x0012_510d, + 0x0032_b313, + 0x0033_d1a5, + 0x0017_50ad, + 0x001c_10c7, + 0x0029_3101, + 0x0009_d067, + 0x0029_51eb, + 0x0019_9013, + 0x001c_107f, + 0x0023_9185, + 0x0009_5059, + 0x0032_b1fd, + 0x0025_7199, + 0x000c_707f, + 0x0001_d011, + 0x000b_300b, + 0x000c_1005, + 0x0020_b10d, + 0x0016_f15b, + 0x000b_507f, + 0x003d_1167, + 0x000e_902b, + 0x0006_100d, + 0x0017_f107, + 0x0015_b0f1, + 0x000d_30ad, + 0x0001_300d, + 0x002a_b0f1, + 0x0026_51df, + 0x0017_f06b, + 0x0023_916f, + 0x0016_f047, + 0x0029_3035, + 0x0006_500d, + 0x000b_500d, + 0x000e_9049, + 0x0023_916f, + 0x0033_5329, + 0x003b_32ef, + 0x0004_f00d, + 0x0025_1071, + 0x0019_902f, + 0x0013_d06b, + 0x0010_f071, + 0x001d_304f, + 0x0042_53d1, + 0x000e_308b, + 0x0006_102f, + 0x000d_3013, + 0x0015_b029, + 0x0024_b06b, + 0x0013_3059, + 0x000e_9011, + 0x001a_50b5, + 0x0014_b101, + 0x0032_92a1, + 0x0006_7059, + 0x0023_b013, + 0x0037_309d, + 0x001a_50fb, + 0x000d_3095, + 0x0023_b06b, + 0x001a_3005, + 0x0030_504f, + 0x0019_9167, + 0x0026_5003, + 0x0013_d119, + 0x0021_d17f, + 0x0009_d071, + 0x0015_b049, + 0x0047_f16f, + 0x0030_10a3, + 0x0033_b2dd, + 0x003f_5305, + 0x001f_d043, + 0x0028_d251, + 0x001a_f1a3, + 0x0018_d16f, + 0x002f_9125, + 0x0002_f013, + 0x0020_b00d, + 0x0023_309d, + 0x0002_f029, + 0x001b_70c7, + 0x0046_30ef, + 0x000d_3035, + 0x0033_d313, + 0x0015_1011, + 0x0002_900d, + 0x001e_7119, + 0x004c_d2c5, + 0x003c_7265, + 0x0034_7059, + 0x001c_9119, + 0x001c_d137, + 0x0018_d0ad, + 0x0035_f0e5, + 0x0018_d10f, + 0x001c_90ad, + 0x0016_10bf, + 0x002a_b035, + 0x0035_50e3, + 0x001f_307f, + 0x0017_503b, + 0x0023_b161, + 0x0071_f6df, + 0x0017_50f1, + 0x0013_d139, + 0x0011_5065, + 0x0041_b28d, + 0x0018_d125, + 0x002e_f0b5, + 0x000c_5005, + 0x0021_d161, + 0x0042_d3df, + 0x0040_71c1, + 0x001c_f00d, + 0x0004_301f, + 0x0031_30e3, + 0x0013_304f, + 0x000b_300d, + 0x0026_b10f, + 0x0013_7065, + 0x000e_50d3, + 0x001b_1065, + 0x0010_f09d, + 0x0044_91c9, + 0x0010_d02b, + 0x0013_7005, + 0x0033_d137, + 0x001e_7095, + 0x0023_b035, + 0x0016_7133, + 0x0028_11c9, + 0x001f_d133, + 0x000b_304f, + 0x0033_7305, + 0x000b_309d, + 0x0021_d00b, + 0x0005_304f, + 0x000a_d0a7, + 0x0016_1139, + 0x0010_d0b3, + 0x0010_d083, + 0x0002_901d, + 0x001c_9097, + 0x001b_1175, + 0x0055_d17f, + 0x0049_d013, + 0x001e_7083, + 0x002e_f0c7, + 0x003d_715d, + 0x0010_1011, + 0x0009_706d, + 0x0026_5139, + 0x0035_90c5, + 0x000c_703b, + 0x0007_f025, + 0x000e_5017, + 0x001e_b119, + 0x0008_3025, + 0x0005_302b, + 0x002d_7053, + 0x0042_d241, + 0x002c_f1a3, + 0x0045_52b3, + 0x0015_1089, + 0x0025_f067, + 0x002d_d003, + 0x0004_f005, + 0x000e_3013, + 0x0010_f083, + 0x002b_3003, + 0x000d_3035, + 0x002c_51b7, + 0x0004_9047, + 0x001e_b101, + 0x001a_510f, + 0x0024_b0fb, + 0x0011_b089, + 0x001a_f059, + 0x002a_523b, + 0x002f_915b, + 0x0032_91e7, + 0x002e_31c9, + 0x0042_72a1, + 0x0011_90c7, + 0x0017_f00d, + 0x000f_b02b, + 0x000f_b0ef, + 0x000f_b07f, + 0x0030_503d, + 0x0010_f029, + 0x0027_7241, + 0x0023_3071, + 0x0003_5025, + 0x000d_f0a7, + 0x002a_b01f, + 0x0013_7133, + 0x002e_306b, + 0x0017_5119, + 0x0023_307f, + 0x0022_d025, + 0x0004_702b, + 0x0012_5003, + 0x0006_b049, + 0x0000_d005, + 0x0000_5003, + 0x0020_91af, + 0x0037_3209, + 0x001c_10e3, + 0x001f_3095, + 0x0012_50c1, + 0x0001_1005, + 0x0025_71bb, + 0x0024_1101, + 0x0015_b119, + 0x000e_902f, + 0x0017_f029, + 0x0011_b07f, + 0x0014_b13d, + 0x0013_7061, + 0x001a_3125, + 0x0006_b04f, + 0x0022_31cf, + 0x0022_d10f, + 0x001a_f125, + 0x0040_910d, + 0x0006_7029, + 0x0015_d0c1, + 0x000c_5049, + 0x0004_7025, + 0x0027_7125, + 0x0007_103d, + 0x005c_9005, + 0x0020_9101, + 0x001a_30b3, + 0x001f_d191, + 0x000c_70a7, + 0x0013_d01d, + 0x0032_b1fd, + 0x000e_30b3, + 0x000f_1053, + 0x001b_70e5, + 0x0024_b071, + 0x001c_9097, + 0x002b_3025, + 0x0022_302b, + 0x0018_5017, + 0x0024_115d, + 0x0015_d089, + 0x000f_102b, + 0x0047_f26b, + 0x0067_91df, + 0x0026_5067, + 0x0034_72ab, + 0x002b_d0c7, + 0x003c_7137, + 0x0018_510d, + 0x000f_b0ad, + 0x0034_71eb, + 0x0016_f07f, + 0x000d_f0bf, + 0x0018_50e3, + 0x000a_d049, + 0x0034_71eb, + 0x0003_b011, + 0x0023_9199, + 0x0035_901f, + 0x000d_303b, + 0x000b_303b, + 0x0016_101d, + 0x0006_b043, + 0x0006_100d, + 0x0001_f005, + 0x001f_31b1, + 0x0028_7047, + 0x0013_d0f1, + 0x0015_d07f, + 0x0014_b133, + 0x0011_500d, + 0x0001_d005, + 0x0019_916f, + 0x001d_30f1, + 0x001f_d097, + 0x0012_50a7, + 0x0006_1029, + 0x0015_d003, + 0x0008_b06d, + 0x0025_106b, + 0x0008_b02f, + 0x0026_b239, + 0x002e_f1a3, + 0x0008_9025, + 0x0023_3053, + 0x0032_b047, + 0x0022_d061, + 0x0026_b06d, + 0x0011_b083, + 0x0028_70a3, + 0x004a_91cd, + 0x0017_5053, + 0x0010_107f, + 0x001c_f06d, + 0x0010_1011, + 0x001c_f00b, + 0x0030_50bf, + 0x0023_911b, + 0x0022_d14b, + 0x0019_1107, + 0x001f_3089, + 0x001c_9035, + 0x001e_b047, + 0x001a_309d, + 0x000f_b0e3, + 0x0015_b115, + 0x0015_d089, + 0x000b_3095, + 0x0006_500d, + 0x0033_506b, + 0x0023_9047, + 0x001e_717b, + 0x002e_31b1, + 0x0011_90d3, + 0x0006_101d, + 0x0025_920b, + 0x000c_708b, + 0x000e_308b, + 0x002a_b101, + 0x0042_715d, + 0x0016_1029, + 0x0010_7035, + 0x001c_10d3, + 0x0024_b00d, + 0x0041_935b, + 0x0017_b0bf, + 0x0033_71c1, + 0x0025_11cf, + 0x0017_b0a3, + 0x000c_5003, + 0x001a_50b5, + 0x002f_9259, + 0x001a_513d, + 0x001b_101f, + 0x003f_10f1, + 0x0011_b00b, + 0x0010_70e5, + 0x0016_711b, + 0x0010_70c5, + 0x0019_10d3, + 0x000e_907f, + 0x000b_f049, + 0x0028_1257, + 0x0003_d01f, + 0x0006_501f, + 0x0052_f4c7, + 0x000c_1089, + 0x0025_9167, + 0x0010_7101, + 0x0010_f025, + 0x0004_9005, + 0x0015_d065, + 0x000e_9097, + 0x001b_b119, + 0x0008_3049, + 0x001c_1083, + 0x000a_3095, + 0x0018_50e3, + 0x0006_100d, + 0x002e_30e9, + 0x0013_90e9, + 0x0002_b005, + 0x0006_7053, + 0x0011_5059, + 0x0028_11eb, + 0x003a_d011, + 0x0023_9139, + 0x000c_707f, + 0x0000_d00b, + 0x0010_f029, + 0x0008_900d, + 0x0017_f053, + 0x0017_50c7, + 0x001f_70c1, + 0x0019_10df, + 0x002f_508b, + 0x000a_3025, + 0x0006_d03d, + 0x000b_f03d, + 0x0075_726b, + 0x0026_91b7, + 0x0025_1241, + 0x002a_517b, + 0x0012_5095, + 0x000a_700d, + 0x003f_d011, + 0x0008_3005, + 0x002f_9043, + 0x0003_d02f, + 0x0028_d22d, + 0x0008_302f, + 0x0033_5011, + 0x0021_d115, + 0x004c_7355, + 0x000c_10b5, + 0x0031_d06b, + 0x0001_700d, + 0x0004_f00d, + 0x003c_71cd, + 0x002f_506d, + 0x0018_5013, + 0x002a_1281, + 0x000a_7061, + 0x0019_9059, + 0x0015_b089, + 0x0008_3065, + 0x001c_110f, + 0x000f_b03d, + 0x0041_9067, + 0x0014_b0ad, + 0x001e_b1d3, + 0x001f_d139, + 0x0020_b053, + 0x0020_91b1, + 0x0001_f00d, + 0x003f_5119, + 0x0028_d065, + 0x0013_902f, + 0x0022_d049, + 0x002a_b139, + 0x0026_b119, + 0x0016_f06d, + 0x000b_f0a3, + 0x0023_916f, + 0x000f_1013, + 0x0017_500b, + 0x0022_d11b, + 0x002b_3259, + 0x0025_9059, + 0x0046_3269, + 0x000d_f043, + 0x003a_1335, + 0x0006_d06b, + 0x001d_300d, + 0x0006_1053, + 0x0008_3043, + 0x0001_f005, + 0x0008_9061, + 0x002b_d293, + 0x000e_f0d3, + 0x004f_d45d, + 0x0009_702b, + 0x0013_d00b, + 0x0039_7005, + 0x000a_d089, + 0x001e_70ad, + 0x0006_d04f, + 0x0015_1137, + 0x0007_104f, + 0x000d_f025, + 0x0022_d18d, + 0x0013_d013, + 0x0002_f029, + 0x0007_1035, + 0x0025_70e5, + 0x0004_3013, + 0x0006_b00b, + 0x0003_b005, + 0x001b_11a5, + 0x0016_70b5, + 0x002b_d13d, + 0x0013_3029, + 0x0019_90e9, + 0x0022_3083, + 0x0072_7641, + 0x0044_507f, + 0x0020_b199, + 0x0015_1095, + 0x001c_1065, + 0x000f_b0ef, + 0x002c_f1d3, + 0x000c_702b, + 0x001c_9011, + 0x000e_50ad, + 0x001e_b049, + 0x0008_3025, + 0x0055_118d, + 0x0039_7337, + 0x0017_b065, + 0x0033_7059, + 0x0022_d0c5, + 0x000f_b065, + 0x001a_3035, + 0x000a_7095, + 0x0014_b139, + 0x0017_b007, + 0x0031_3061, + 0x0024_b005, + 0x000d_f0c7, + 0x0061_14a3, + 0x0030_500d, + 0x001c_115d, + 0x0027_709d, + 0x0006_102f, + 0x001c_1061, + 0x0009_501f, + 0x0013_7107, + 0x001a_5175, + 0x0016_709d, + 0x0012_5035, + 0x0016_7137, + 0x0006_b02f, + 0x001f_7139, + 0x0040_9293, + 0x001a_501d, + 0x000f_b035, + 0x0013_d0b3, + 0x0013_d0bf, + 0x0018_d0e5, + 0x002e_313d, + 0x001d_f0c1, + 0x002b_d1cf, + 0x0040_f097, + 0x002d_7025, + 0x001e_7029, + 0x0005_900d, + 0x0019_1035, + 0x0023_91d3, + 0x0008_902b, + 0x0004_f043, + 0x0016_7059, + 0x000b_f089, + 0x0025_9053, + 0x0019_9175, + 0x0007_f06b, + 0x0038_f067, + 0x0028_d095, + 0x001f_70ad, + 0x001f_d1bb, + 0x0018_506b, + 0x001b_b1b7, + 0x001a_500d, + 0x0016_10a7, + 0x0055_13b3, + 0x0006_7025, + 0x0004_703d, + 0x000f_b06b, + 0x0011_50a7, + 0x000c_10b5, + 0x001a_f151, + 0x000b_f00d, + 0x0026_91cd, + 0x001c_90e3, + 0x001b_b0ef, + 0x0010_f08b, + 0x000a_703d, + 0x0008_b043, + 0x003f_1067, + 0x0023_3097, + 0x002b_315b, + 0x0033_b095, + 0x0003_b013, + 0x004f_f40f, + 0x0020_b0c1, + 0x001a_302b, + 0x004a_910f, + 0x000c_100b, + 0x0007_f01f, + 0x0018_d0c5, + 0x000a_3095, + 0x0011_5029, + 0x002f_9137, + 0x0015_b13d, + 0x0013_300d, + 0x008e_12cf, + 0x0026_9259, + 0x0031_323b, + 0x0016_7107, + 0x003f_128d, + 0x0013_90a3, + 0x0013_900d, + 0x002d_d017, + 0x000f_1025, + 0x0019_904f, + 0x001a_f0c1, + 0x0022_304f, + 0x0006_d005, + 0x0016_10e9, + 0x0055_7175, + 0x0033_d1e7, + 0x0044_30f1, + 0x0001_f005, + 0x0017_f15b, + 0x0010_f047, + 0x0022_d1a3, + 0x0033_b161, + 0x002c_50a7, + 0x0025_1151, + 0x0027_71af, + 0x0011_9029, + 0x0013_307f, + 0x0011_b0c5, + 0x001b_b061, + 0x0037_70c5, + 0x0076_d0e5, + 0x0020_906b, + 0x0020_90c5, + 0x0002_9025, + 0x001f_d0ef, + 0x0026_50c5, + 0x0025_f251, + 0x0025_1035, + 0x0003_500d, + 0x0040_f251, + 0x0040_f3ad, + 0x0017_b053, + 0x000d_f0ad, + 0x0074_f5ad, + 0x002a_51df, + 0x007c_34eb, + 0x0024_11c9, + 0x0018_d01d, + 0x001a_5071, + 0x001a_f067, + 0x0044_5239, + 0x0031_d2e3, + 0x0010_f101, + 0x0014_b0fb, + 0x0023_304f, + 0x0009_d013, + 0x0006_b059, + 0x0009_706b, + 0x003f_d251, + 0x0016_7011, + 0x0044_92ab, + 0x002e_3259, + 0x0007_1011, + 0x001f_316f, + 0x0016_711b, + 0x0037_113d, + 0x0007_1025, + 0x0017_5095, + 0x003b_90e5, + 0x0025_7185, + 0x000c_503b, + 0x0040_72bd, + 0x002e_3167, + 0x0019_1005, + 0x000e_50b5, + 0x000a_d035, + 0x0010_10ad, + 0x0023_b1df, + 0x001e_710f, + 0x0007_f06d, + 0x0006_7059, + 0x001a_f185, + 0x0017_f02f, + 0x000b_f065, + 0x0029_3097, + 0x0006_5049, + 0x0010_f067, + 0x0009_d03d, + 0x0013_d02b, + 0x004c_d3c7, + 0x0019_916f, + 0x001b_10e9, + 0x000b_30ad, + 0x001e_b067, + 0x000e_f0e3, + 0x002f_92f5, + 0x0010_d0df, + 0x0006_500d, + 0x0006_b067, + 0x0006_1005, + 0x001c_9029, + 0x0010_101d, + 0x0024_111b, + 0x0007_f005, + 0x0035_5059, + 0x0010_7083, + 0x000f_b07f, + 0x000d_f03d, + 0x001f_3003, + 0x0028_d0b5, + 0x001b_1115, + 0x0009_7053, + 0x003f_11f3, + 0x0008_904f, + 0x0016_70d3, + 0x0004_f03d, + 0x0014_b071, + 0x001c_9029, + 0x001c_d00d, + 0x0040_f3fb, + 0x0015_b01d, + 0x0001_f00d, + 0x0017_f047, + 0x001f_7043, + 0x0026_9139, + 0x002b_d0e9, + 0x001b_b191, + 0x0010_d03d, + 0x0046_345d, + 0x0026_504f, + 0x0009_d00d, + 0x001c_1043, + 0x0029_3167, + 0x005c_f0e3, + 0x0010_10a3, + 0x000e_f00d, + 0x000b_3089, + 0x002e_f071, + 0x0017_f061, + 0x0017_b071, + 0x0033_d0ef, + 0x001f_7095, + 0x0015_b115, + 0x0019_1125, + 0x0024_11f7, + 0x0006_b067, + 0x0022_d0ad, + 0x0010_d0a3, + 0x000f_103d, + 0x000b_f061, + 0x0006_5049, + 0x0018_d08b, + 0x001a_f00b, + 0x0019_90a7, + 0x001d_30e3, + 0x0002_b013, + 0x0013_90e3, + 0x001a_f14b, + 0x0042_71eb, + 0x001c_90e3, + 0x0047_f371, + 0x0013_d101, + 0x0064_1151, + 0x001d_300d, + 0x0025_704f, + 0x0015_d107, + 0x002a_b013, + 0x0015_10f1, + 0x0006_5029, + 0x0010_1005, + 0x0031_31eb, + 0x0018_d043, + 0x0010_10fb, + 0x000e_300d, + 0x0009_d035, + 0x003a_d25f, + 0x0007_1025, + 0x0059_3107, + 0x001d_f071, + 0x0034_71eb, + 0x000b_3005, + 0x0006_d011, + 0x0015_b067, + 0x0024_11f7, + 0x0024_11df, + 0x001e_b043, + 0x002a_10b3, + 0x001c_d16f, + 0x0029_51a5, + 0x0005_303b, + 0x0000_7005, + 0x0003_b00d, + 0x0008_3035, + 0x000f_100d, + 0x0013_7115, + 0x0028_30a3, + 0x0009_d059, + 0x0023_9005, + 0x002e_31f7, + 0x003b_9095, + 0x0033_b2d7, + 0x0031_d025, + 0x0016_7043, + 0x0026_9071, + 0x001f_3065, + 0x0031_3119, + 0x0017_f0e3, + 0x001f_7199, + 0x0014_b03b, + 0x0011_904f, + 0x0024_b137, + 0x000e_9083, + 0x002a_102b, + 0x0022_d0f1, + 0x0018_d0d3, + 0x0013_7125, + 0x002e_70e9, + 0x000c_709d, + 0x000d_f0a7, + 0x002e_3097, + 0x0034_71f7, + 0x000c_7029, + 0x0006_701d, + 0x0002_b01f, + 0x0006_5035, + 0x000e_9065, + 0x0035_52e7, + 0x0011_503d, + 0x0035_f071, + 0x000b_5005, + 0x001b_b10d, + 0x0015_106b, + 0x000e_90b5, + 0x0015_b03d, + 0x0041_b2f9, + 0x000e_90c5, + 0x0010_7017, + 0x0018_d03b, + 0x0001_100d, + 0x0020_b083, + 0x0024_11fd, + 0x0007_f029, + 0x002f_52cf, + 0x002e_f287, + 0x0013_7101, + 0x0013_3125, + 0x003d_1151, + 0x0025_1029, + 0x0000_d003, + 0x004a_9005, + 0x0028_1209, + 0x000c_1043, + 0x0006_d053, + 0x0028_70c1, + 0x001b_706b, + 0x001e_b09d, + 0x0006_d03d, + 0x0010_70ef, + 0x0010_7061, + 0x0026_5259, + 0x0006_5043, + 0x0017_b07f, + 0x0022_31f3, + 0x002e_f1fd, + 0x0002_b005, + 0x000b_5035, + 0x0018_5089, + 0x000d_307f, + 0x0028_31cd, + 0x0005_303b, + 0x001c_9011, + 0x0059_34cf, + 0x0017_b029, + 0x0033_d13d, + 0x0013_d0a7, + 0x000c_5035, + 0x0017_b0fb, + 0x002b_3013, + 0x0025_f0e9, + 0x001a_310f, + 0x0026_b209, + 0x0013_d0d3, + 0x0023_b0c5, + 0x002f_925f, + 0x001b_b071, + 0x0006_5035, + 0x0029_3241, + 0x0015_d0b5, + 0x0015_b0e5, + 0x000d_f08b, + 0x0027_70fb, + 0x0002_f005, + 0x001b_117f, + 0x0028_7049, + 0x0004_701f, + 0x004c_f4c7, + 0x0013_3049, + 0x0029_5005, + 0x0061_148b, + 0x0022_d071, + 0x0044_f005, + 0x0013_7059, + 0x001a_f0fb, + 0x0032_b02b, + 0x0033_d18d, + 0x0011_5065, + 0x000f_1049, + 0x0020_9047, + 0x0004_3013, + 0x000c_7049, + 0x001f_7125, + 0x0006_100d, + 0x0009_d095, + 0x0016_f06b, + 0x0019_9059, + 0x000f_b097, + 0x0002_f003, + 0x000d_30bf, + 0x001b_b199, + 0x0011_500d, + 0x003f_b241, + 0x0014_b005, + 0x0031_3233, + 0x000e_30b5, + 0x0020_9185, + 0x0084_124b, + 0x0057_7095, + 0x0018_d107, + 0x0043_f233, + 0x0064_102b, + 0x0007_102f, + 0x0028_306d, + 0x0019_1137, + 0x0010_d0d3, + 0x0009_503b, + 0x0013_300d, + 0x002d_7083, + 0x0050_3269, + 0x0040_f287, + 0x0017_b0c1, + 0x0040_f33d, + 0x003b_300d, + 0x0010_7053, + 0x0021_d0c5, + 0x002a_5151, + 0x0013_3067, + 0x0018_d10d, + 0x0003_b007, + 0x0007_1061, + 0x001c_d053, + 0x000b_3011, + 0x001a_50df, + 0x000a_d059, + 0x0028_71bb, + 0x001c_101f, + 0x001c_1025, + 0x001b_b043, + 0x007c_d00d, + 0x0011_910d, + 0x0047_f133, + 0x001a_501d, + 0x0019_90a3, + 0x0004_901f, + 0x0044_9277, + 0x000e_501d, + 0x0006_b01f, + 0x002a_1065, + 0x0018_517f, + 0x000b_f01f, + 0x000b_5005, + 0x005b_f21d, + 0x0035_92f5, + 0x004c_1065, + 0x0016_f007, + 0x0031_d2ef, + 0x0009_7005, + 0x0013_310f, + 0x000f_b06d, + 0x0006_1013, + 0x000d_3049, + 0x001a_500b, + 0x003b_900d, + 0x0011_902b, + 0x0001_700b, + 0x0016_f00d, + 0x0012_50f1, + 0x0055_d22d, + 0x0029_318d, + 0x0032_b137, + 0x000a_d095, + 0x001d_3151, + 0x0028_11f7, + 0x0026_b1f3, + 0x001a_f11b, + 0x002d_d035, + 0x000a_d005, + 0x0016_f025, + 0x003d_f3cb, + 0x002b_3239, + 0x0025_70e9, + 0x0023_30a3, + 0x0010_103b, + 0x003c_7013, + 0x0039_7137, + 0x0020_b0e3, + 0x000b_301d, + 0x0006_d065, + 0x001f_d00d, + 0x001a_30bf, + 0x0028_d02b, + 0x002a_10c7, + 0x0017_b115, + 0x0023_31b7, + 0x001a_506d, + 0x000f_1059, + 0x002c_52b3, + 0x0009_5089, + 0x0005_900d, + 0x0026_9043, + 0x0028_3119, + 0x0023_90ef, + 0x0056_54c1, + 0x000a_7061, + 0x000a_303b, + 0x0035_51fd, + 0x0006_103d, + 0x001c_d02b, + 0x0005_302b, + 0x0015_d067, + 0x0015_b115, + 0x0010_101d, + 0x0010_d095, + 0x0018_d0e3, + 0x0015_10c7, + 0x003f_d0fb, + 0x001e_b0c1, + 0x000e_304f, + 0x0017_b047, + 0x000c_1035, + 0x001b_b089, + 0x0032_9115, + 0x002e_f21d, + 0x0008_b059, + 0x0023_915b, + 0x002f_5281, + 0x000c_10a7, + 0x0020_918d, + 0x0025_10c5, + 0x0034_72ab, + 0x000e_9053, + 0x0028_d20b, + 0x001a_50a7, + 0x0015_d0b5, + 0x004a_335b, + 0x0010_7007, + 0x000f_b0d3, + 0x0028_d0ef, + 0x0055_71cd, + 0x0033_b265, + 0x000b_3043, + 0x002b_d1b1, + 0x0013_907f, + 0x002e_f295, + 0x0017_b0e9, + 0x0023_916f, + 0x002a_52a1, + 0x0052_940f, + 0x001a_f0df, + 0x0011_90ef, + 0x001b_709d, + 0x0002_5003, + 0x003b_9209, + 0x002b_3097, + 0x000a_d017, + 0x0015_d06d, + 0x003a_9259, + 0x0010_f00b, + 0x000e_f06d, + 0x0025_924b, + 0x002d_723b, + 0x001e_70a3, + 0x0017_f08b, + 0x000e_304f, + 0x0004_9043, + 0x001b_1101, + 0x0022_302b, + 0x0007_f005, + 0x0038_f1c9, + 0x002d_d0bf, + 0x0025_903d, + 0x000f_107f, + 0x0017_f167, + 0x0017_b0a3, + 0x002b_d095, + 0x0004_9005, + 0x0034_72b3, + 0x000c_7083, + 0x0033_b2c5, + 0x0007_f03d, + 0x001f_30b5, + 0x0028_70fb, + 0x0009_d04f, + 0x0004_7043, + 0x001c_d151, + 0x001f_d107, + 0x000c_101d, + 0x001d_f0b5, + 0x0018_508b, + 0x0005_304f, + 0x003f_d02b, + 0x001c_9139, + 0x001d_301f, + 0x0024_b083, + 0x0013_d089, + 0x0006_100d, + 0x001d_f10f, + 0x0021_d1a5, + 0x0024_1005, + 0x000c_100d, + 0x001a_500d, + 0x0010_d043, + 0x0015_b059, + 0x002c_f06d, + 0x0037_11f3, + 0x004a_3151, + 0x0024_10a7, + 0x0017_f10d, + 0x0017_f15b, + 0x0001_f00b, + 0x0013_911b, + 0x000b_300d, + 0x0025_f059, + 0x001a_f0df, + 0x0013_d0e9, + 0x000f_1043, + 0x0013_9007, + 0x0016_f03b, + 0x0006_d067, + 0x002d_7007, + 0x0020_b03d, + 0x000b_f061, + 0x002e_32c5, + 0x0014_b11b, + 0x001b_1175, + 0x001a_500d, + 0x0006_b04f, + 0x000f_b0b3, + 0x0034_70df, + 0x0023_30c7, + 0x0011_510f, + 0x001e_b049, + 0x0028_d025, + 0x0042_7265, + 0x001b_1025, + 0x0013_7065, + 0x0003_d003, + 0x0002_5011, + 0x0013_d089, + 0x0029_3065, + 0x0030_115b, + 0x0009_d029, + 0x001f_7053, + 0x001a_50e3, + 0x0003_502f, + 0x001a_5029, + 0x0015_d137, + 0x0019_918d, + 0x000b_3097, + 0x001a_50c7, + 0x0034_70e5, + 0x001f_7191, + 0x001f_7095, + 0x002a_507f, + 0x001c_9151, + 0x0025_7139, + 0x000b_307f, + 0x0004_f005, + 0x0017_b0c5, + 0x0028_704f, + 0x003e_53df, + 0x0032_9101, + 0x0022_d1df, + 0x0011_b0df, + 0x0010_1025, + 0x001d_3025, + 0x000b_5095, + 0x001a_300d, + 0x0015_d0e5, + 0x0017_5151, + 0x0035_b017, + 0x0020_b1b1, + 0x003f_536d, + 0x000d_f049, + 0x0004_7043, + 0x0013_d0c5, + 0x0016_10ad, + 0x0031_d167, + 0x0024_b0f1, + 0x0026_516f, + 0x0016_100b, + 0x001a_50c7, + 0x0037_125f, + 0x0017_502b, + 0x002e_303d, + 0x0003_b00b, + 0x000c_5005, + 0x0013_3101, + 0x002b_d095, + 0x0030_1059, + 0x0023_3043, + 0x0009_7007, + 0x0020_91a3, + 0x0019_9137, + 0x000a_3011, + 0x001f_7011, + 0x0007_1035, + 0x0033_7071, + 0x0008_3007, + 0x0018_d137, + 0x0011_b00d, + 0x000b_302b, + 0x001e_b0bf, + 0x0046_923b, + 0x0016_1107, + 0x0008_901d, + 0x000e_f0e3, + 0x0042_5089, + 0x0031_d08b, + 0x0009_7047, + 0x0010_7025, + 0x002b_d0ef, + 0x0011_b0df, + 0x0056_5335, + 0x001d_f025, + 0x0005_900b, + 0x000c_1059, + 0x001b_1095, + 0x0013_7005, + 0x000e_509d, + 0x001b_10c1, + 0x0026_91eb, + 0x0039_710d, + 0x0038_b0ad, + 0x0002_900d, + 0x0026_917f, + 0x0003_b007, + 0x0028_316f, + 0x001c_10ef, + 0x000d_309d, + 0x0025_9167, + 0x0016_f029, + 0x0017_f14b, + 0x0029_5025, + 0x000b_f03d, + 0x0009_502f, + 0x002b_d257, + 0x0012_5089, + 0x0013_d107, + 0x0059_538b, + 0x0015_d0c7, + 0x000f_10ad, + 0x0022_d1d3, + 0x0004_900b, + 0x0027_710f, + 0x0009_5043, + 0x001c_d18d, + 0x001d_f0a3, + 0x0017_b04f, + 0x0015_106b, + 0x0051_50f1, + 0x001a_5185, + 0x002d_70e9, + 0x0014_b0d3, + 0x0006_5005, + 0x0019_106b, + 0x0032_91a3, + 0x0020_b1a5, + 0x001a_30c1, + 0x000c_709d, + 0x0016_101f, + 0x0022_d00d, + 0x0016_708b, + 0x0013_d049, + 0x003a_d0f1, + 0x0020_b017, + 0x0015_b11b, + 0x001b_110d, + 0x001c_d005, + 0x000e_300d, + 0x0029_3283, + 0x001a_510d, + 0x002f_90ad, + 0x0024_b119, + 0x0011_900b, + 0x000f_b083, + 0x0022_d083, + 0x0030_10f1, + 0x001b_101d, + 0x000c_70b5, + 0x0015_d0d3, + 0x002b_31fd, + 0x0025_f223, + 0x0007_f017, + 0x001f_7049, + 0x001f_71f3, + 0x0020_b119, + 0x0006_b043, + 0x0025_7089, + 0x0033_d0b5, + 0x001b_702b, + 0x002f_92dd, + 0x0014_b107, + 0x0006_7025, + 0x000a_301d, + 0x0011_b003, + 0x0009_706d, + 0x0013_3013, + 0x0012_504f, + 0x0004_900d, + 0x0016_70bf, + 0x0013_7003, + 0x000b_306b, + 0x000c_10a7, + 0x0028_3265, + 0x001b_100d, + 0x0007_f03d, + 0x001a_3017, + 0x0004_f047, + 0x002c_f139, + 0x0001_d00d, + 0x000c_703b, + 0x0025_91c9, + 0x001c_90fb, + 0x0013_7119, + 0x0006_d065, + 0x002f_9097, + 0x0015_1115, + 0x000f_b06d, + 0x0002_900d, + 0x0013_d013, + 0x0028_d1f3, + 0x0017_f007, + 0x0041_b161, + 0x0025_f125, + 0x003e_5133, + 0x0039_7025, + 0x0021_d00d, + 0x000e_9083, + 0x002b_d233, + 0x0010_1095, + 0x0022_30df, + 0x0045_d2e7, + 0x0002_901d, + 0x0052_91c9, + 0x0010_d059, + 0x0035_506b, + 0x0013_30e3, + 0x0026_b175, + 0x004e_12f9, + 0x0027_7167, + 0x0004_7013, + 0x0013_7005, + 0x0005_300d, + 0x0010_d071, + 0x0003_b005, + 0x0009_d097, + 0x0023_31a3, + 0x0002_f029, + 0x000c_500d, + 0x0013_7119, + 0x0038_f355, + 0x0025_9025, + 0x0003_d029, + 0x000a_d0a7, + 0x000d_300b, + 0x0031_d281, + 0x001c_d1c1, + 0x001e_b065, + 0x0013_700d, + 0x0006_704f, + 0x0027_7035, + 0x001c_d0a3, + 0x0049_3043, + 0x002c_f0fb, + 0x0035_f06b, + 0x0025_f21d, + 0x004f_d40f, + 0x0023_b119, + 0x0013_7071, + 0x000c_70b5, + 0x0010_70a7, + 0x0018_d06d, + 0x0013_d005, + 0x0019_1115, + 0x001d_306b, + 0x000d_f065, + 0x0006_d011, + 0x0018_d01d, + 0x0040_7283, + 0x0005_3025, + 0x0004_f043, + 0x0010_70ef, + 0x0006_7043, + 0x0018_503d, + 0x001c_1003, + 0x0026_b0a3, + 0x0027_704f, + 0x0038_b301, + 0x0035_b1a5, + 0x001c_d1af, + 0x000b_f011, + 0x001a_30df, + 0x002f_52e7, + 0x002a_5223, + 0x0035_909d, + 0x001c_10b3, + 0x001b_b133, + 0x0028_3223, + 0x0022_31c9, + 0x0003_d003, + 0x002e_32b3, + 0x0013_70e5, + 0x0010_d01f, + 0x0011_903b, + 0x0003_d035, + 0x0025_7097, + 0x0040_f32b, + 0x0013_30fb, + 0x001f_7115, + 0x0014_b03b, + 0x0026_903b, + 0x0025_70bf, + 0x0029_301d, + 0x001c_f1c9, + 0x0018_50df, + 0x000e_3025, + 0x0011_90b5, + 0x0017_5115, + 0x0004_f01d, + 0x001e_b0fb, + 0x0010_701d, + 0x0009_5065, + 0x004e_b3b3, + 0x0035_50c1, + 0x0019_1043, + 0x001a_3167, + 0x0023_b053, + 0x0021_d10f, + 0x004a_3005, + 0x0013_30b5, + 0x0007_102f, + 0x0010_d0c1, + 0x0003_b01f, + 0x0010_f0b5, + 0x002d_d265, + 0x0008_3029, + 0x006b_b63d, + 0x0020_90c5, + 0x001c_f0bf, + 0x0029_30b5, + 0x0020_906b, + 0x003d_107f, + 0x0022_d0ad, + 0x000e_30bf, + 0x0042_7251, + 0x0022_315d, + 0x000c_5013, + 0x0015_d11b, + 0x0012_504f, + 0x001e_70d3, + 0x0013_7005, + 0x002e_f1df, + 0x001f_308b, + 0x003e_523b, + 0x0019_9139, + 0x001c_f167, + 0x0016_f01f, + 0x000b_503b, + 0x000a_7005, + 0x0006_d06b, + 0x0021_d0c5, + 0x000d_f005, + 0x004d_50a3, + 0x0017_507f, + 0x002c_510f, + 0x002d_d0b3, + 0x0006_d061, + 0x001d_317f, + 0x0016_710d, + 0x0027_7265, + 0x000f_b029, + 0x002a_5175, + 0x001a_f00b, + 0x0033_7277, + 0x001f_d00b, + 0x0017_5059, + 0x000a_d06d, + 0x0010_10f1, + 0x003f_11c9, + 0x0029_50bf, + 0x0004_7005, + 0x0029_31df, + 0x0016_101d, + 0x0026_b1b7, + 0x0023_9017, + 0x0015_d00b, + 0x001d_314b, + 0x000c_103d, + 0x0008_b02f, + 0x003d_715d, + 0x0010_f035, + 0x002f_928d, + 0x0045_d335, + 0x0025_7029, + 0x001c_106d, + 0x000b_5053, + 0x0029_513d, + 0x001f_30d3, + 0x000e_3043, + 0x0033_d185, + 0x0005_3013, + 0x0017_b005, + 0x0031_3003, + 0x0003_b01d, + 0x000d_f047, + 0x0017_b161, + 0x0033_52dd, + 0x001b_703d, + 0x0002_901d, + 0x0032_b329, + 0x0035_90fb, + 0x003a_d065, + 0x0010_1065, + 0x000e_300d, + 0x0044_5013, + 0x0036_d1b7, + 0x003f_d3b3, + 0x0015_b06d, + 0x0026_b0bf, + 0x0023_30c1, + 0x002a_5005, + 0x000b_303d, + 0x0025_9151, + 0x000a_700d, + 0x001d_f15d, + 0x0030_1047, + 0x0032_9139, + 0x0008_b01f, + 0x001a_51a3, + 0x0016_f0b3, + 0x001c_f14b, + 0x001e_71b1, + 0x0001_7005, + 0x000e_3049, + 0x0011_9043, + 0x0016_f0a3, + 0x000e_302f, + 0x003d_1137, + 0x0014_b0df, + 0x0013_90fb, + 0x0046_921d, + 0x0030_50e3, + 0x0028_d0ad, + 0x001e_7151, + 0x000e_5049, + 0x000c_7053, + 0x003c_b191, + 0x0025_706d, + 0x000d_f043, + 0x002c_5065, + 0x0003_d013, + 0x0025_7119, + 0x0037_70d3, + 0x001b_1137, + 0x000a_d00d, + 0x001f_7053, + 0x0017_515b, + 0x0031_3083, + 0x0020_b119, + 0x0007_1005, + 0x0041_940f, + 0x001a_5065, + 0x0007_1007, + 0x003d_f03d, + 0x0010_103d, + 0x0001_d00d, + 0x0023_b115, + 0x0016_1119, + 0x0010_f067, + 0x000d_3071, + 0x005d_50a7, + 0x0023_b00b, + 0x0002_b01f, + 0x003c_7059, + 0x0004_303d, + 0x0018_d06d, + 0x002c_f059, + 0x003f_52ef, + 0x001b_703d, + 0x0040_9065, + 0x0024_b15b, + 0x0011_90b5, + 0x0013_9071, + 0x0006_b04f, + 0x0013_903b, + 0x0016_1101, + 0x002f_9101, + 0x0015_d125, + 0x0003_5003, + 0x002a_b0ef, + 0x003f_10c1, + 0x0035_90fb, + 0x0019_9007, + 0x003b_316f, + 0x0028_d09d, + 0x0014_b06d, + 0x0005_300b, + 0x0020_91c1, + 0x0009_501f, + 0x0058_1337, + 0x0040_90bf, + 0x0028_115b, + 0x0014_b089, + 0x001f_30ad, + 0x0005_304f, + 0x0018_516f, + 0x0031_d167, + 0x0001_d00b, + 0x000c_501d, + 0x0020_b09d, + 0x0018_d0c1, + 0x0021_d065, + 0x002c_f23b, + 0x001e_b013, + 0x0002_f00b, + 0x0025_f06b, + 0x001b_1107, + 0x001f_30b3, + 0x000a_d007, + 0x0022_3049, + 0x0023_b1d3, + 0x0022_d035, + 0x0025_9095, + 0x0002_b005, + 0x001b_10c7, + 0x0009_5047, + 0x0038_f1b1, + 0x001a_307f, + 0x0012_50fb, + 0x0019_109d, + 0x0029_5139, + 0x0002_501f, + 0x0018_d005, + 0x003a_90fb, + 0x0016_7017, + 0x0026_b01d, + 0x001f_d0df, + 0x001d_f0c1, + 0x001a_507f, + 0x000a_700d, + 0x0003_d00d, + 0x0019_10b5, + 0x002d_7239, + 0x0038_b00b, + 0x0017_50c7, + 0x001c_d15d, + 0x0028_d0fb, + 0x0015_d00b, + 0x000c_700d, + 0x0008_b03d, + 0x001a_f15d, + 0x000e_506b, + 0x0003_b00d, + 0x0015_d09d, + 0x0015_b005, + 0x002d_d191, + 0x001b_b03d, + 0x000b_500b, + 0x0018_50c7, + 0x0002_900d, + 0x001f_31e7, + 0x0005_903b, + 0x002e_f0bf, + 0x0006_5061, + 0x0035_5239, + 0x0014_b0c1, + 0x001f_3007, + 0x0029_307f, + 0x0011_b0a7, + 0x0016_70bf, + 0x0015_b133, + 0x000a_7097, + 0x000c_1035, + 0x000e_f003, + 0x0004_7035, + 0x000b_f01d, + 0x0010_7089, + 0x0026_b047, + 0x0020_b1a3, + 0x000a_d049, + 0x0015_d02b, + 0x000c_7029, + 0x0031_d03d, + 0x0010_d00d, + 0x0008_3005, + 0x0037_11b7, + 0x0016_f025, + 0x002f_516f, + 0x000e_506b, + 0x0041_b2f5, + 0x000a_3013, + 0x0020_91c1, + 0x0015_b059, + 0x0004_9007, + 0x0017_50a3, + 0x000f_b0e3, + 0x0012_5065, + 0x0008_9005, + 0x0014_b059, + 0x001a_3035, + 0x002a_b09d, + 0x001b_11af, + 0x0018_d133, + 0x0024_b1c9, + 0x003e_5175, + 0x0042_52cf, + 0x0025_110f, + 0x001f_d137, + 0x0043_f083, + 0x000a_7035, + 0x001a_5125, + 0x0025_923b, + 0x000b_3053, + 0x0013_d02b, + 0x002e_708b, + 0x0035_5065, + 0x0028_111b, + 0x002e_f20b, + 0x0028_30b3, + 0x000e_f00d, + 0x001b_1185, + 0x0004_f011, + 0x0016_106b, + 0x000b_f025, + 0x001a_f10f, + 0x0038_f1c9, + 0x0002_f01d, + 0x0025_f0d3, + 0x0052_f2e3, + 0x0010_d09d, + 0x000b_507f, + 0x0037_11af, + 0x001b_7175, + 0x0017_f0b5, + 0x0026_90d3, + 0x001a_311b, + 0x001f_d09d, + 0x0003_b035, + 0x000e_5053, + 0x0061_1599, + 0x0017_f0fb, + 0x0006_d049, + 0x0037_10c7, + 0x0013_300d, + 0x001d_f013, + 0x0009_706d, + 0x002d_d1df, + 0x0018_d029, + 0x0016_110f, + 0x0019_110f, + 0x0016_713d, + 0x0044_3257, + 0x0017_f02b, + 0x0042_50ad, + 0x0029_30b3, + 0x0044_f2b3, + 0x002b_d1af, + 0x000a_703b, + 0x002e_f199, + 0x000e_f047, + 0x0013_3125, + 0x0004_300b, + 0x000a_3065, + 0x0022_d0c1, + 0x0033_d313, + 0x000b_3011, + 0x0015_1107, + 0x0025_f259, + 0x0018_50c7, + 0x000f_107f, + 0x0006_d02b, + 0x0024_111b, + 0x002e_7097, + 0x003e_5337, + 0x0011_50e9, + 0x0046_3097, + 0x0015_d0bf, + 0x0010_7047, + 0x000c_70b5, + 0x0006_5011, + 0x0018_502f, + 0x0004_700d, + 0x002d_7257, + 0x0001_300b, + 0x0049_d2c5, + 0x000b_301d, + 0x002b_30c7, + 0x000d_3071, + 0x0011_503d, + 0x001b_10f1, + 0x0023_b08b, + 0x0035_520b, + 0x0008_b049, + 0x0033_51b7, + 0x0006_5049, + 0x000b_504f, + 0x0035_9337, + 0x0001_1005, + 0x0007_f03b, + 0x000c_503d, + 0x001d_314b, + 0x0051_7355, + 0x0031_31a5, + 0x000c_5059, + 0x0019_9017, + 0x0013_d09d, + 0x0033_b17b, + 0x0040_7139, + 0x001f_706d, + 0x0011_50e3, + 0x0020_9137, + 0x0010_101d, + 0x0017_b0e5, + 0x0018_d11b, + 0x0025_10b5, + 0x0001_d00d, + 0x000c_5053, + 0x003c_71df, + 0x0009_5049, + 0x0015_d00d, + 0x001d_3061, + 0x0015_d10f, + 0x0016_7065, + 0x0048_101d, + 0x0044_316f, + 0x0038_f33d, + 0x0011_5029, + 0x0017_509d, + 0x000c_5065, + 0x0001_1007, + 0x001f_3083, + 0x0011_b06d, + 0x0016_109d, + 0x0025_114b, + 0x001b_b01d, + 0x002b_30e5, + 0x002f_9133, + 0x001d_f167, + 0x002a_1119, + 0x002b_d17b, + 0x0033_b0c1, + 0x0005_300b, + 0x0029_3005, + 0x0004_f02f, + 0x0010_f08b, + 0x0009_703b, + 0x0014_b005, + 0x0004_3005, + 0x0013_7083, + 0x0013_d067, + 0x002b_d089, + 0x0021_d1f7, + 0x001a_50e5, + 0x000e_f02b, + 0x0026_b15b, + 0x0000_b005, + 0x0000_d005, + 0x0006_d00d, + 0x0025_f18d, + 0x000d_f03b, + 0x0006_5061, + 0x000e_30bf, + 0x0017_b15d, + 0x0003_b02b, + 0x003e_5115, + 0x0035_f095, + 0x005d_b17f, + 0x001b_1005, + 0x000b_303b, + 0x0028_1269, + 0x0013_901f, + 0x0010_7071, + 0x0026_500d, + 0x0010_f007, + 0x0006_7011, + 0x002a_507f, + 0x0010_d011, + 0x000f_1095, + 0x0023_9223, + 0x001b_101d, + 0x0033_b011, + 0x003f_d13d, + 0x002d_d137, + 0x002b_d20b, + 0x0018_d071, + 0x0028_1047, + 0x001a_30a7, + 0x0033_b20b, + 0x002a_513d, + 0x0023_90d3, + 0x001f_30bf, + 0x001e_711b, + 0x0042_d2d7, + 0x0030_5005, + 0x003d_12d7, + 0x0013_704f, + 0x003b_3025, + 0x001d_f0c7, + 0x0024_110f, + 0x0025_7089, + 0x0004_3005, + 0x0015_1107, + 0x001f_d1f7, + 0x0038_b2e7, + 0x004e_b0c7, + 0x003f_53b3, + 0x0018_d119, + 0x0017_5053, + 0x0016_f03b, + 0x0020_b1a3, + 0x003d_f0bf, + 0x001b_1013, + 0x0041_b33b, + 0x0019_90c1, + 0x000e_3089, + 0x001f_3029, + 0x000d_f06b, + 0x0023_b0f1, + 0x0008_3049, + 0x0027_71e7, + 0x0009_d043, + 0x001e_b089, + 0x0008_3005, + 0x003a_d295, + 0x0035_f0ad, + 0x0016_706b, + 0x0024_b0fb, + 0x0024_1017, + 0x0016_1029, + 0x0021_d04f, + 0x0031_322d, + 0x0028_d0e3, + 0x0026_5065, + 0x000e_908b, + 0x001a_5115, + 0x0023_31e7, + 0x000e_f053, + 0x0028_302f, + 0x002e_30b3, + 0x0007_f035, + 0x000a_7005, + 0x001a_f0bf, + 0x0015_10fb, + 0x0058_f397, + 0x0006_7059, + 0x0030_5017, + 0x001c_d14b, + 0x0029_30d3, + 0x0015_b0e3, + 0x0012_5065, + 0x000e_903b, + 0x000a_7025, + 0x0017_b049, + 0x0026_9265, + 0x0020_b0c7, + 0x0001_d017, + 0x002a_108b, + 0x000b_308b, + 0x0044_5005, + 0x0013_d119, + 0x002c_f097, + 0x0035_9003, + 0x0028_30a7, + 0x001f_d0d3, + 0x0018_5137, + 0x003d_71c1, + 0x0009_7043, + 0x0006_5007, + 0x0035_906b, + 0x002e_30fb, + 0x000c_106d, + 0x0022_31bb, + 0x0029_3059, + 0x001c_9071, + 0x0022_30a7, + 0x004c_f003, + 0x002d_d1bb, + 0x0013_70e3, + 0x000e_f059, + 0x0017_501d, + 0x001f_313d, + 0x001c_10b3, + 0x000a_d08b, + 0x0032_b185, + 0x0013_d0fb, + 0x0028_d287, + 0x000b_5013, + 0x0035_92bd, + 0x000b_302f, + 0x001c_f01d, + 0x0013_9013, + 0x0042_d355, + 0x0031_d0ef, + 0x002f_504f, + 0x0028_7119, + 0x0028_715b, + 0x0010_d03d, + 0x003d_f06b, + 0x0011_50c5, + 0x001b_b00d, + 0x0015_1035, + 0x0087_15e7, + 0x000d_30c5, + 0x000d_f0c7, + 0x0017_50a3, + 0x0007_1017, + 0x0004_3003, + 0x0011_5005, + 0x0006_502b, + 0x0010_7083, + 0x0019_903b, + 0x0013_9035, + 0x000c_7025, + 0x000b_301d, + 0x001b_118d, + 0x0006_100d, + 0x0001_300b, + 0x0045_d005, + 0x001a_f017, + 0x0019_10df, + 0x0003_d025, + 0x0008_9029, + 0x0035_b1a3, + 0x0033_510d, + 0x000f_b0d3, + 0x0011_9101, + 0x0011_909d, + 0x0013_7125, + 0x0010_d0df, + 0x0003_b025, + 0x0016_103b, + 0x0006_d01d, + 0x0028_11a3, + 0x0010_f043, + 0x001c_f053, + 0x0007_f011, + 0x0033_b2e3, + 0x0017_5025, + 0x0010_f047, + 0x001c_f011, + 0x0001_7005, + 0x000b_306b, + 0x000d_30c1, + 0x0059_34a9, + 0x0023_91b1, + 0x003a_d115, + 0x0017_5071, + 0x0023_b059, + 0x002e_f0bf, + 0x000a_307f, + 0x000e_90e5, + 0x001d_30e5, + 0x001e_b047, + 0x0003_5025, + 0x0011_50e5, + 0x0019_1061, + 0x000a_7011, + 0x000f_b061, + 0x0034_70a7, + 0x0025_7005, + 0x0013_d053, + 0x001a_50f1, + 0x0014_b08b, + 0x0016_7133, + 0x0010_f0df, + 0x0055_10e3, + 0x0016_714b, + 0x000a_7053, + 0x0016_10e3, + 0x005b_f1a3, + 0x002a_5269, + 0x001c_f1a3, + 0x0026_9115, + 0x001d_303b, + 0x0010_1049, + 0x0018_d151, + 0x0035_b1fd, + 0x0017_b14b, + 0x0035_9083, + 0x0001_100d, + 0x0028_7043, + 0x0025_71bb, + 0x0015_d02b, + 0x0011_9013, + 0x0009_501d, + 0x0001_f005, + 0x0013_900d, + 0x0000_d005, + 0x0017_f08b, + 0x001d_f089, + 0x001c_904f, + 0x000c_1083, + 0x0014_b0fb, + 0x0028_30fb, + 0x002b_d035, + 0x0046_324b, + 0x0013_311b, + 0x001c_1119, + 0x0004_3025, + 0x000b_50ad, + 0x0007_f03d, + 0x000a_d043, + 0x0015_b007, + 0x000b_303d, + 0x0032_b061, + 0x0033_d337, + 0x0007_1049, + 0x0004_9011, + 0x001d_f13d, + 0x005d_b16f, + 0x0033_71e7, + 0x000c_5025, + 0x0017_b15b, + 0x002e_32dd, + 0x0040_f03d, + 0x003e_5133, + 0x001b_10a3, + 0x0025_70e5, + 0x001e_b059, + 0x0009_507f, + 0x0018_d007, + 0x001b_7185, + 0x0016_1107, + 0x006f_72ef, + 0x0011_b119, + 0x0008_9043, + 0x0011_50df, + 0x0011_b035, + 0x0009_5025, + 0x0026_9107, + 0x002e_f005, + 0x0016_115b, + 0x0016_f01d, + 0x0010_100d, + 0x0044_93d1, + 0x0019_915b, + 0x002d_d185, + 0x0020_9043, + 0x0033_d013, + 0x003f_d083, + 0x0029_5233, + 0x0010_7007, + 0x0015_1097, + 0x0017_5071, + 0x0037_30fb, + 0x001a_306b, + 0x002b_d0bf, + 0x0038_b01d, + 0x0043_f139, + 0x0011_b08b, + 0x0010_10ad, + 0x0017_f0ad, + 0x0035_f161, + 0x0037_3277, + 0x001a_3043, + 0x0018_50f1, + 0x0023_3071, + 0x0035_9233, + 0x0011_906d, + 0x001f_70c5, + 0x0006_7005, + 0x0029_514b, + 0x0035_b083, + 0x0046_913d, + 0x001e_b00d, + 0x0009_d047, + 0x0017_b02f, + 0x0013_d003, + 0x0011_5067, + 0x0015_d067, + 0x002e_72b3, + 0x0029_5185, + 0x0023_9005, + 0x0010_f0b5, + 0x0071_32f9, + 0x001f_701f, + 0x0016_70e3, + 0x001b_b07f, + 0x0010_d01d, + 0x0029_3283, + 0x0031_d2b3, + 0x000e_303d, + 0x000e_f097, + 0x0023_b005, + 0x000e_909d, + 0x0003_b005, + 0x0021_d15d, + 0x0016_f005, + 0x0051_73f1, + 0x0060_75c9, + 0x0013_9125, + 0x0011_50e9, + 0x0009_700b, + 0x000e_9061, + 0x0018_d09d, + 0x0010_f071, + 0x002a_1097, + 0x0028_10c5, + 0x000f_b0b3, + 0x001b_100d, + 0x0033_50b3, + 0x002e_f1fd, + 0x000b_f067, + 0x000c_5059, + 0x0028_1191, + 0x0071_f125, + 0x000b_f059, + 0x0013_3101, + 0x0008_307f, + 0x0007_102b, + 0x0030_1281, + 0x0030_103d, + 0x001f_70d3, + 0x0004_f043, + 0x0025_923b, + 0x0038_b233, + 0x0011_500d, + 0x001d_300b, + 0x0011_9047, + 0x0022_3049, + 0x0012_5065, + 0x0013_d097, + 0x0004_f00d, + 0x0032_90b5, + 0x0026_914b, + 0x0059_9005, + 0x0003_b00d, + 0x0008_900d, + 0x0003_5029, + 0x001c_d061, + 0x0060_7355, + 0x003f_d32b, + 0x0035_b2bd, + 0x000d_3071, + 0x0028_d185, + 0x0025_700d, + 0x000c_5065, + 0x0037_702f, + 0x0028_722d, + 0x001a_f095, + 0x000c_501d, + 0x0011_9097, + 0x0028_71cf, + 0x001f_3003, + 0x002a_b1a3, + 0x0025_90ad, + 0x001a_5005, + 0x001b_1025, + 0x001b_1095, + 0x0013_310f, + 0x0028_1239, + 0x000b_303b, + 0x0005_9047, + 0x0020_b0a7, + 0x0011_90e3, + 0x000a_d053, + 0x0030_1083, + 0x003d_1049, + 0x0005_900d, + 0x001e_b005, + 0x0029_50fb, + 0x0017_b0e9, + 0x0007_f065, + 0x0015_d02b, + 0x001a_500d, + 0x0010_702b, + 0x0008_9053, + 0x0028_7097, + 0x000c_1017, + 0x001c_f03b, + 0x0016_10c5, + 0x0025_f067, + 0x001e_70c7, + 0x0009_d06d, + 0x0006_1059, + 0x0018_d151, + 0x002a_b25f, + 0x003c_72d7, + 0x0029_30b3, + 0x000a_d061, + 0x0007_1029, + 0x004e_1407, + 0x0010_f011, + 0x0061_7599, + 0x001d_f0fb, + 0x0000_d005, + 0x000b_508b, + 0x002b_3283, + 0x001a_f0ad, + 0x0019_1151, + 0x0015_b065, + 0x001d_316f, + 0x0016_f0df, + 0x004e_12dd, + 0x0005_3035, + 0x0022_3053, + 0x001e_71b1, + 0x0012_500b, + 0x0023_918d, + 0x000d_f0c5, + 0x002d_d101, + 0x003c_7223, + 0x0025_915d, + 0x0011_b0e3, + 0x0013_709d, + 0x0028_d223, + 0x0030_1059, + 0x0008_b06b, + 0x0010_f065, + 0x0031_d0f1, + 0x0006_1005, + 0x002a_b01d, + 0x0022_d0bf, + 0x0013_702b, + 0x0046_9223, + 0x0023_b0ad, + 0x0016_701d, + 0x0024_b22d, + 0x0025_f137, + 0x001b_715b, + 0x002a_b1cd, + 0x000b_503b, + 0x0015_1035, + 0x0026_915b, + 0x0016_1061, + 0x0014_b0c1, + 0x001a_500d, + 0x0016_70fb, + 0x003f_5347, + 0x0016_f065, + 0x000c_5065, + 0x0018_d029, + 0x000d_f00d, + 0x0040_7061, + 0x000d_30b5, + 0x000e_50c5, + 0x001e_70d3, + 0x0025_10fb, + 0x001e_7119, + 0x0025_1065, + 0x0041_91c9, + 0x000d_303d, + 0x000a_7005, + 0x000e_90e5, + 0x0004_900b, + 0x0005_9049, + 0x0044_f005, + 0x0001_d00d, + 0x0005_9005, + 0x0020_90e3, + 0x001c_10b5, + 0x0007_f06d, + 0x001d_f1cf, + 0x0056_52a1, + 0x001b_11a5, + 0x001f_d119, + 0x002b_300b, + 0x0035_b2f9, + 0x0017_5161, + 0x0028_3017, + 0x0002_b00d, + 0x0013_9003, + 0x0015_d08b, + 0x0028_3115, + 0x0015_101d, + 0x000e_307f, + 0x0004_903d, + 0x002e_f22d, + 0x0018_500d, + 0x001d_f00d, + 0x002d_7005, + 0x000b_306b, + 0x001c_906d, + 0x0017_f14b, + 0x000c_7089, + 0x0004_9025, + 0x0023_90b3, + 0x0042_52dd, + 0x0011_b0ef, + 0x001b_7083, + 0x0013_90c1, + 0x0049_3053, + 0x000f_10ad, + 0x0025_700d, + 0x0009_502f, + 0x002d_d239, + 0x0016_10b3, + 0x001a_f15d, + 0x0032_913d, + 0x000b_f06b, + 0x000f_b00d, + 0x001f_717b, + 0x001d_f133, + 0x002d_d133, + 0x0013_9115, + 0x0020_b15d, + 0x0042_d083, + 0x0024_1089, + 0x0005_3017, + 0x000d_302f, + 0x000b_f061, + 0x000a_d011, + 0x000e_301f, + 0x0012_510d, + 0x000f_b043, + 0x0011_507f, + 0x004c_11c1, + 0x001e_70bf, + 0x0002_901d, + 0x000c_70ad, + 0x0006_5047, + 0x003a_100d, + 0x0016_715b, + 0x0009_704f, + 0x002f_517f, + 0x0013_9047, + 0x0013_d119, + 0x001e_70a7, + 0x0013_70c7, + 0x0038_b0c7, + 0x0055_71b1, + 0x0010_f049, + 0x0020_903d, + 0x0017_f0d3, + 0x0013_711b, + 0x000e_9011, + 0x000a_7083, + 0x0011_50e9, + 0x0015_b025, + 0x001a_50e9, + 0x002b_323b, + 0x0001_d00d, + 0x001d_f1d3, + 0x0015_1047, + 0x0041_b283, + 0x0035_f185, + 0x000c_106b, + 0x000b_3071, + 0x0035_50bf, + 0x0023_9071, + 0x0032_9283, + 0x000e_501d, + 0x002f_92e3, + 0x0035_b2a5, + 0x003f_b15d, + 0x000e_306b, + 0x001b_1025, + 0x0020_b005, + 0x000a_7017, + 0x002f_5167, + 0x0011_b0e3, + 0x0016_f0f1, + 0x0015_b0f1, + 0x0010_7043, + 0x001b_10e5, + 0x0016_f0bf, + 0x001f_706b, + 0x001a_5089, + 0x0010_70ef, + 0x000e_502b, + 0x001f_711b, + 0x0016_f0a3, + 0x0002_500b, + 0x000a_3071, + 0x001c_d083, + 0x0002_9007, + 0x0006_102b, + 0x000b_5061, + 0x0017_b02b, + 0x0014_b02f, + 0x005c_b0ef, + 0x0001_300d, + 0x0013_d01f, + 0x0014_b107, + 0x000a_300d, + 0x0010_f0e9, + 0x000d_30b5, + 0x0011_50e9, + 0x0013_90c5, + 0x003b_90e9, + 0x000b_3071, + 0x0051_11fd, + 0x001a_3119, + 0x002b_d1f7, + 0x0019_10e5, + 0x000c_107f, + 0x0014_b029, + 0x000e_902b, + 0x001a_f061, + 0x0043_f251, + 0x0029_5137, + 0x0075_707f, + 0x0023_303d, + 0x0016_f03b, + 0x0023_b025, + 0x001a_5029, + 0x001b_b199, + 0x0033_d1cd, + 0x0006_d043, + 0x0049_d1d3, + 0x000c_7017, + 0x0016_113d, + 0x0010_f07f, + 0x001c_d1a5, + 0x0009_5047, + 0x0017_f139, + 0x0016_714b, + 0x003f_d18d, + 0x0002_501f, + 0x0025_f0b3, + 0x0033_5101, + 0x000f_b02b, + 0x002f_5125, + 0x001f_7059, + 0x000c_70ad, + 0x0028_102b, + 0x002b_d097, + 0x0031_3277, + 0x000a_7061, + 0x0006_1025, + 0x0009_5035, + 0x000f_b0a3, + 0x0013_9095, + 0x0011_b08b, + 0x0034_728d, + 0x001b_1161, + 0x0016_7137, + 0x0005_9025, + 0x0019_916f, + 0x0028_d1cd, + 0x0022_3049, + 0x0022_d21d, + 0x0020_b00b, + 0x0003_b011, + 0x000d_f095, + 0x0015_b119, + 0x0008_902f, + 0x0019_100d, + 0x0005_9005, + 0x0041_93b3, + 0x0009_d049, + 0x0031_32f9, + 0x002e_f277, + 0x002a_51eb, + 0x002a_10a3, + 0x0034_7025, + 0x0029_526b, + 0x001e_7011, + 0x0031_d17b, + 0x0010_70ef, + 0x0003_d003, + 0x0012_500d, + 0x0052_93b9, + 0x000b_50b3, + 0x0002_9025, + 0x000a_d061, + 0x0042_5293, + 0x0009_d00d, + 0x0013_706d, + 0x0009_503b, + 0x0014_b06d, + 0x0010_f04f, + 0x0033_b1fd, + 0x0005_9005, + 0x0018_501f, + 0x0010_f06b, + 0x0009_5005, + 0x000e_50c5, + 0x000e_50c1, + 0x001a_506d, + 0x0013_30a7, + 0x000c_5043, + 0x001a_50a7, + 0x0018_d17b, + 0x0035_b1cd, + 0x001c_9017, + 0x0004_702b, + 0x001c_91b7, + 0x0013_30bf, + 0x0038_f251, + 0x000d_f0d3, + 0x001f_d0b5, + 0x0004_7035, + 0x0014_b06d, + 0x000e_9047, + 0x0017_b0e5, + 0x0013_701d, + 0x0020_b0fb, + 0x0013_9061, + 0x0006_500b, + 0x001f_300d, + 0x001f_717f, + 0x0030_5161, + 0x0013_9067, + 0x0005_9013, + 0x0032_b15d, + 0x0019_10c5, + 0x0038_f1b7, + 0x003d_7047, + 0x0042_7281, + 0x0037_31b7, + 0x0004_9025, + 0x0006_7005, + 0x0013_30fb, + 0x000e_909d, + 0x001c_d101, + 0x002c_5097, + 0x0024_b01f, + 0x0006_d005, + 0x0026_91cf, + 0x0015_b06d, + 0x0011_9017, + 0x000e_f03d, + 0x0031_d2ef, + 0x001f_30c7, + 0x0025_91b7, + 0x0022_3167, + 0x0009_7003, + 0x0024_b0b3, + 0x001b_1185, + 0x0008_9017, + 0x0022_308b, + 0x0039_7239, + 0x002e_f065, + 0x0003_d00d, + 0x0020_b02f, + 0x0018_5133, + 0x002e_3233, + 0x0033_d1f7, + 0x0009_d02b, + 0x0010_7089, + 0x0027_701d, + 0x0008_b067, + 0x0010_10ef, + 0x0006_b049, + 0x0020_b0e5, + 0x000e_30a7, + 0x000b_5061, + 0x0037_324b, + 0x0013_d133, + 0x0047_f02b, + 0x000b_3049, + 0x0029_30bf, + 0x0042_73cb, + 0x000f_1097, + 0x0009_d005, + 0x000a_d071, + 0x0025_910d, + 0x001c_102b, + 0x002a_115d, + 0x0010_f0fb, + 0x000f_b0a7, + 0x0011_500b, + 0x0010_1029, + 0x0022_3083, + 0x002a_108b, + 0x0036_d005, + 0x0013_302b, + 0x0009_5071, + 0x0029_3005, + 0x000b_f071, + 0x0010_d0c7, + 0x001a_310f, + 0x001a_511b, + 0x0028_d223, + 0x004e_b047, + 0x0021_d02f, + 0x0024_b035, + 0x0031_d2bd, + 0x0017_b175, + 0x000e_3043, + 0x0035_b2ab, + 0x0003_502b, + 0x0008_9005, + 0x0045_d08b, + 0x000a_7035, + 0x0011_b0fb, + 0x0035_5337, + 0x0016_f0e3, + 0x000c_70ad, + 0x0017_f03d, + 0x000d_f03b, + 0x0006_5029, + 0x0026_9137, + 0x001b_1097, + 0x0015_d0e9, + 0x0001_3005, + 0x0021_d115, + 0x001b_108b, + 0x004b_1265, + 0x0018_5061, + 0x001c_f175, + 0x0009_5005, + 0x0017_b00d, + 0x0023_b049, + 0x002f_52ab, + 0x001c_d1a3, + 0x000e_9035, + 0x001c_908b, + 0x0021_d065, + 0x001f_3071, + 0x0026_50e5, + 0x0020_b04f, + 0x0020_b1b7, + 0x001b_113d, + 0x000d_f0c5, + 0x002a_5095, + 0x001c_917f, + 0x001b_7151, + 0x0002_9013, + 0x0004_3035, + 0x0011_908b, + 0x0029_50ad, + 0x000e_f06b, + 0x0011_901d, + 0x0038_f241, + 0x001d_30b3, + 0x0004_9029, + 0x0028_3139, + 0x001c_f0c1, + 0x0009_706d, + 0x0013_90ef, + 0x0010_704f, + 0x0002_b013, + 0x0024_b053, + 0x000c_101f, + 0x0026_501d, + 0x0022_300b, + 0x0019_1083, + 0x0009_d071, + 0x0016_f043, + 0x0022_3013, + 0x0011_9097, + 0x0017_f01d, + 0x0031_31cd, + 0x0025_9119, + 0x0013_7053, + 0x0008_9011, + 0x0027_7029, + 0x0005_904f, + 0x001e_70ad, + 0x0013_9137, + 0x000a_d049, + 0x0028_d1b7, + 0x0025_f02f, + 0x0040_9167, + 0x0012_5005, + 0x000c_7029, + 0x001a_3035, + 0x0013_d09d, + 0x0060_d2c5, + 0x0032_9233, + 0x0008_b005, + 0x001c_f061, + 0x000b_503b, + 0x0023_3095, + 0x0035_b2bd, + 0x000e_3043, + 0x0019_90c5, + 0x0015_d0e5, + 0x000c_7035, + 0x000a_d06d, + 0x0011_50bf, + 0x001c_d01d, + 0x0028_701d, + 0x003b_90c7, + 0x0005_3005, + 0x000e_3053, + 0x002c_f005, + 0x0011_5097, + 0x001f_70b3, + 0x0022_3097, + 0x0038_b2a1, + 0x002e_728d, + 0x0016_711b, + 0x002b_d047, + 0x0024_b17f, + 0x0010_700d, + 0x003f_b16f, + 0x004c_d3fd, + 0x0014_b083, + 0x001e_710d, + 0x0010_f06d, + 0x000c_7097, + 0x001e_70b5, + 0x002a_111b, + 0x0005_9053, + 0x001f_d1e7, + 0x0005_9053, + 0x000e_f0c1, + 0x002a_5139, + 0x0010_d09d, + 0x001c_9067, + 0x0008_b04f, + 0x0001_700d, + 0x0008_900b, + 0x0003_d035, + 0x0018_d0ef, + 0x000b_5089, + 0x001d_f1d3, + 0x0011_50d3, + 0x0008_9053, + 0x0015_b017, + 0x005a_70ad, + 0x000f_107f, + 0x000e_307f, + 0x001e_70c7, + 0x0012_50b5, + 0x0029_51b1, + 0x0015_d025, + 0x001a_5089, + 0x0032_92e7, + 0x0010_f047, + 0x0013_d053, + 0x0016_f137, + 0x0033_d269, + 0x001f_31af, + 0x000e_303b, + 0x0008_307f, + 0x0035_b32b, + 0x0011_b03d, + 0x0030_51df, + 0x0038_f1eb, + 0x000c_100d, + 0x0009_d06b, + 0x0051_5449, + 0x002a_1139, + 0x000e_3005, + 0x0049_d00d, + 0x0028_d0c7, + 0x0016_1097, + 0x0016_f067, + 0x000c_7029, + 0x000e_3089, + 0x0013_3025, + 0x001b_7053, + 0x000e_500d, + 0x001b_700d, + 0x001a_50c7, + 0x0017_f035, + 0x0028_71d3, + 0x0015_d097, + 0x0006_d017, + 0x0025_7185, + 0x0009_d089, + 0x0037_1293, + 0x000f_106d, + 0x001f_d0df, + 0x0009_706d, + 0x001f_d071, + 0x0025_f065, + 0x0032_b03d, + 0x004b_d15b, + 0x0019_107f, + 0x0006_b005, + 0x000b_f04f, + 0x0005_301f, + 0x000c_701f, + 0x001a_f00d, + 0x001b_b137, + 0x0023_b03d, + 0x0042_d043, + 0x0024_b097, + 0x0011_b053, + 0x0059_f47f, + 0x0002_b029, + 0x0013_d083, + 0x0037_306b, + 0x000a_d09d, + 0x0001_300d, + 0x0059_3053, + 0x0017_50ad, + 0x000a_3053, + 0x0020_9089, + 0x000f_10b3, + 0x0010_f0bf, + 0x0035_90f1, + 0x000e_504f, + 0x0023_9185, + 0x0033_b1cd, + 0x001c_f059, + 0x0017_506b, + 0x000e_9061, + 0x0006_702b, + 0x0008_300d, + 0x0015_d06d, + 0x003f_d059, + 0x000f_b00b, + 0x0020_9011, + 0x002b_3185, + 0x0022_31c9, + 0x0013_307f, + 0x0010_103b, + 0x0015_103d, + 0x0004_f047, + 0x0040_713d, + 0x001a_f0ad, + 0x001d_3125, + 0x001a_50c7, + 0x001c_107f, + 0x001f_d14b, + 0x0004_f049, + 0x000b_5061, + 0x000c_5043, + 0x0023_3089, + 0x000c_7067, + 0x0024_b0c5, + 0x0023_b007, + 0x0016_f125, + 0x0018_5161, + 0x005a_d025, + 0x0027_725f, + 0x0026_9049, + 0x002c_5043, + 0x000d_308b, + 0x0003_500b, + 0x0022_d06d, + 0x003d_f013, + 0x0025_1199, + 0x002d_71a5, + 0x0007_103b, + 0x0035_f095, + 0x000e_501d, + 0x001c_10c5, + 0x000d_f059, + 0x0030_5137, + 0x000b_f07f, + 0x0008_900d, + 0x000a_3089, + 0x001f_d0b5, + 0x0017_f10f, + 0x002b_321d, + 0x001d_30e9, + 0x0023_303b, + 0x0015_b09d, + 0x0035_52a5, + 0x0033_b0e3, + 0x0012_511b, + 0x001c_9089, + 0x003f_1059, + 0x0009_d02f, + 0x0031_31a5, + 0x000e_5047, + 0x0011_501f, + 0x0020_b1df, + 0x005a_b2c5, + 0x000d_f005, + 0x0042_72bd, + 0x0036_d2a5, + 0x0007_f017, + 0x001a_501f, + 0x000b_5013, + 0x0010_1047, + 0x002b_d043, + 0x000a_d00b, + 0x001a_f0b3, + 0x0001_f00d, + 0x0002_5011, + 0x003e_53a9, + 0x0011_5011, + 0x0010_1025, + 0x001a_3025, + 0x0032_9065, + 0x0020_b1a3, + 0x0023_321d, + 0x0017_f0ad, + 0x0003_502b, + 0x000b_300d, + 0x0011_9003, + 0x000a_3083, + 0x005a_d373, + 0x0031_d01f, + 0x0029_51af, + 0x0019_906d, + 0x0010_7005, + 0x0027_7209, + 0x001a_513d, + 0x0035_b259, + 0x003b_31a5, + 0x000b_f013, + 0x002c_52a5, + 0x0014_b0b5, + 0x0011_508b, + 0x0008_3047, + 0x0000_d00b, + 0x0015_10fb, + 0x0011_b035, + 0x001c_f199, + 0x001f_3125, + 0x000c_50a7, + 0x0023_3061, + 0x001a_f095, + 0x0020_b1c9, + 0x0010_d09d, + 0x0003_b00d, + 0x003d_7281, + 0x0032_921d, + 0x0008_303b, + 0x000d_f007, + 0x000c_706d, + 0x0008_3007, + 0x0005_3005, + 0x001c_f119, + 0x0018_d017, + 0x004f_d2b3, + 0x003c_700d, + 0x002c_5071, + 0x001c_9017, + 0x0023_9043, + 0x0010_70c7, + 0x0022_d191, + 0x003a_9005, + 0x0010_f0fb, + 0x001d_30c5, + 0x0025_11cd, + 0x002b_31a5, + 0x0028_3059, + 0x0019_9065, + 0x0010_f097, + 0x000d_f065, + 0x000a_d09d, + 0x0026_521d, + 0x000f_10c5, + 0x003b_9071, + 0x002a_101f, + 0x002e_f00d, + 0x0021_d17b, + 0x000b_f07f, + 0x0002_b00b, + 0x003f_110d, + 0x002e_716f, + 0x0020_9005, + 0x002a_b06b, + 0x0040_f409, + 0x0009_7013, + 0x003f_510d, + 0x0032_b2f9, + 0x0012_501f, + 0x0027_713d, + 0x000c_7005, + 0x001b_710f, + 0x001e_7071, + 0x0023_300b, + 0x001a_f017, + 0x0005_9053, + 0x0011_906b, + 0x0011_b0ef, + 0x0016_f059, + 0x0020_9137, + 0x0029_3097, + 0x0013_3125, + 0x0019_9035, + 0x0033_d2bd, + 0x001b_715d, + 0x0024_101f, + 0x000f_1035, + 0x0008_900d, + 0x0014_b0e3, + 0x0004_3005, + 0x0017_50a7, + 0x002b_d2a1, + 0x0015_d0a7, + 0x0006_d00d, + 0x0008_302f, + 0x0033_d04f, + 0x0020_91eb, + 0x001d_f1af, + 0x0030_500d, + 0x0019_109d, + 0x001e_700d, + 0x004a_303b, + 0x002c_f067, + 0x0039_7059, + 0x0032_921d, + 0x001d_3017, + 0x0019_10a7, + 0x0005_3049, + 0x0006_5035, + 0x0016_7097, + 0x000a_d071, + 0x003d_f35f, + 0x0024_1137, + 0x001c_91a5, + 0x0033_508b, + 0x0020_b07f, + 0x002a_106d, + 0x0009_d053, + 0x000e_f083, + 0x0004_7035, + 0x0016_7089, + 0x002c_50a7, + 0x0034_71c9, + 0x002b_d2ab, + 0x0010_d095, + 0x0049_d28d, + 0x0012_501d, + 0x0011_508b, + 0x0026_91e7, + 0x000e_f09d, + 0x0028_300d, + 0x0036_d337, + 0x004a_3035, + 0x0015_d139, + 0x0044_9025, + 0x0023_908b, + 0x0018_d0c5, + 0x001b_b0ad, + 0x0028_3097, + 0x0065_50d3, + 0x0046_33fd, + 0x001c_d013, + 0x0006_7035, + 0x0011_506b, + 0x0009_506d, + 0x0028_7115, + 0x0017_f065, + 0x0025_9025, + 0x0040_f1a5, + 0x0006_d00d, + 0x001d_3049, + 0x003e_52ab, + 0x0016_f161, + 0x001d_3185, + 0x0017_5133, + 0x0038_b21d, + 0x0026_91cf, + 0x0045_d161, + 0x001f_d03b, + 0x002f_500d, + 0x002b_d0a7, + 0x001d_3053, + 0x001c_1013, + 0x002e_72bd, + 0x003c_b239, + 0x001f_d00d, + 0x000a_308b, + 0x001b_b11b, + 0x0059_f0ad, + 0x0007_1017, + 0x0013_d013, + 0x000e_300d, + 0x000a_d005, + 0x001a_f049, + 0x001f_d14b, + 0x0009_d049, + 0x0019_9061, + 0x0004_7017, + 0x000a_3071, + 0x0033_d07f, + 0x0018_d0e3, + 0x0006_d03d, + 0x0044_918d, + 0x001a_f035, + 0x0037_717f, + 0x001f_31b1, + 0x0025_900d, + 0x000b_f00d, + 0x0010_10c5, + 0x0011_5013, + 0x0032_9107, + 0x000b_3035, + 0x000a_302b, + 0x0028_d0a3, + 0x0020_918d, + 0x0035_b2a1, + 0x001a_503d, + 0x0014_b0e9, + 0x0009_700d, + 0x0017_5025, + 0x0064_9013, + 0x0056_522d, + 0x0024_1209, + 0x0006_100b, + 0x002d_71c9, + 0x0017_f0b3, + 0x0017_50bf, + 0x000a_d013, + 0x0003_5013, + 0x000c_704f, + 0x003a_915d, + 0x0017_f151, + 0x0050_3445, + 0x0024_b101, + 0x001d_f17f, + 0x0020_91c1, + 0x0016_10d3, + 0x0028_116f, + 0x0010_f00d, + 0x0014_b035, + 0x002a_b065, + 0x0013_30e5, + 0x000a_d0a3, + 0x000b_3059, + 0x001e_b04f, + 0x0011_9107, + 0x001c_902b, + 0x001d_f13d, + 0x0009_d06b, + 0x0018_d067, + 0x004b_13df, + 0x0023_b017, + 0x0018_508b, + 0x000e_f00d, + 0x004d_535f, + 0x0020_90c5, + 0x0018_5083, + 0x002e_706b, + 0x000f_1095, + 0x0029_523b, + 0x0011_50df, + 0x0028_70e3, + 0x003e_5301, + 0x001e_b11b, + 0x002a_b0a3, + 0x0021_d0ad, + 0x001d_30e5, + 0x0014_b115, + 0x001d_31b7, + 0x0018_d00d, + 0x000a_7029, + 0x002c_f269, + 0x0024_b06b, + 0x0065_510d, + 0x0030_506d, + 0x000a_d011, + 0x0029_503d, + 0x0004_701d, + 0x0006_d029, + 0x000c_50b5, + 0x0025_f1bb, + 0x0042_d35f, + 0x001f_d089, + 0x002c_f2a1, + 0x0006_b029, + 0x002f_515d, + 0x0016_f13d, + 0x0022_300d, + 0x0015_d0e9, + 0x003d_11f3, + 0x0021_d0b5, + 0x0026_5223, + 0x0007_100d, + 0x000e_f0a7, + 0x0017_5119, + 0x0006_102b, + 0x0023_3223, + 0x0025_7071, + 0x000e_503b, + 0x000c_102b, + 0x0033_b2bd, + 0x0017_f151, + 0x0016_700b, + 0x0017_5007, + 0x002c_516f, + 0x001a_f059, + 0x001b_7151, + 0x001e_710d, + 0x002b_313d, + 0x0015_d101, + 0x0010_1005, + 0x0023_9029, + 0x0008_9043, + 0x0027_702b, + 0x0024_1095, + 0x0019_9061, + 0x0003_b025, + 0x0023_920b, + 0x0020_90f1, + 0x0010_10a7, + 0x0026_b139, + 0x0077_3025, + 0x0013_d137, + 0x0032_9251, + 0x000f_b065, + 0x0011_900b, + 0x0020_b1bb, + 0x001f_d06d, + 0x001e_715b, + 0x003a_12c5, + 0x000d_3005, + 0x001e_b007, + 0x0022_d00d, + 0x003d_101f, + 0x0019_910f, + 0x0025_f1fd, + 0x0004_f01f, + 0x002c_5013, + 0x0002_f025, + 0x000e_500b, + 0x003a_d00d, + 0x0036_d035, + 0x004c_11e7, + 0x0005_304f, + 0x000d_f097, + 0x0010_d029, + 0x0001_d005, + 0x000c_706d, + 0x000c_109d, + 0x002c_f257, + 0x000f_b083, + 0x001d_31c9, + 0x001b_7003, + 0x0026_b241, + 0x0001_3005, + 0x0023_90e9, + 0x0005_3025, + 0x0004_f01d, + 0x0026_b233, + 0x0032_9185, + 0x0016_f133, + 0x000c_1089, + 0x0024_10c1, + 0x0037_11cd, + 0x0017_5101, + 0x001b_b09d, + 0x001a_3107, + 0x000e_f09d, + 0x0009_d03d, + 0x000a_7047, + 0x000e_30df, + 0x004c_d2cf, + 0x0033_50bf, + 0x0028_3025, + 0x0051_b503, + 0x0010_d0d3, + 0x0021_d04f, + 0x0013_903b, + 0x000e_508b, + 0x0006_b01f, + 0x0016_109d, + 0x001c_d0d3, + 0x0017_b10d, + 0x000a_3025, + 0x0025_110f, + 0x001d_f14b, + 0x001e_71c9, + 0x0025_100d, + 0x0012_5005, + 0x002f_907f, + 0x0018_501d, + 0x0010_d049, + 0x004b_1397, + 0x0009_d03b, + 0x0035_51bb, + 0x0019_100d, + 0x003d_100d, + 0x001b_70f1, + 0x0035_b287, + 0x003d_703d, + 0x0030_50c7, + 0x0022_d1f3, + 0x0049_33b3, + 0x002e_72a1, + 0x002b_d293, + 0x003d_133b, + 0x0016_10df, + 0x001b_1065, + 0x0015_10c7, + 0x0020_90c5, + 0x0019_903d, + 0x0015_1013, + 0x000e_f02f, + 0x001b_1137, + 0x0035_f125, + 0x0016_711b, + 0x0004_f011, + 0x0025_f0ef, + 0x001c_d0e9, + 0x000d_306b, + 0x0025_7161, + 0x0010_70d3, + 0x0042_d059, + 0x0028_1025, + 0x002b_3017, + 0x004c_7175, + 0x001f_3167, + 0x001c_1137, + 0x0019_915d, + 0x000d_306b, + 0x000a_300d, + 0x0013_d11b, + 0x000c_7025, + 0x0003_b017, + 0x0017_b02b, + 0x0017_f071, + 0x0001_f017, + 0x0017_f03d, + 0x0029_3223, + 0x0016_f125, + 0x0009_7029, + 0x0035_b0bf, + 0x0004_7005, + 0x0033_b03b, + 0x0009_501d, + 0x002b_d28d, + 0x0017_f137, + 0x0019_1013, + 0x001e_b06d, + 0x0013_d125, + 0x0006_1025, + 0x0055_73df, + 0x001a_f03b, + 0x0024_11cf, + 0x001b_b17b, + 0x0019_104f, + 0x0038_b0ad, + 0x001b_b0e9, + 0x001a_3185, + 0x0032_b08b, + 0x0023_30a7, + 0x0004_701f, + 0x0004_f00b, + 0x0033_b2f9, + 0x000f_b0b3, + 0x000e_f0d3, + 0x0009_7061, + 0x001c_102f, + 0x0004_301f, + 0x0010_d097, + 0x0028_123b, + 0x0018_515b, + 0x001d_f01f, + 0x0032_9305, + 0x000b_3097, + 0x000c_7089, + 0x000e_309d, + 0x001b_1067, + 0x0016_f0b3, + 0x001e_b0ef, + 0x0008_b049, + 0x0026_500b, + 0x0004_9007, + 0x0028_1097, + 0x001b_b191, + 0x0006_1011, + 0x0017_b07f, + 0x000e_90c7, + 0x0000_5003, + 0x0032_91df, + 0x0030_514b, + 0x0038_b035, + 0x001a_5161, + 0x0026_b1eb, + 0x0013_7083, + 0x0012_506b, + 0x004c_7061, + 0x0002_500d, + 0x0033_7095, + 0x002b_d1df, + 0x0011_b07f, + 0x001f_307f, + 0x0000_d005, + 0x0010_f06d, + 0x0015_10f1, + 0x000b_309d, + 0x0006_d029, + 0x0034_7119, + 0x0030_51cd, + 0x002a_1067, + 0x0037_72ab, + 0x0004_3013, + 0x0009_d01f, + 0x0016_1139, + 0x002a_5293, + 0x0006_1047, + 0x001c_f03d, + 0x000e_f03d, + 0x0011_b00d, + 0x0011_b089, + 0x0009_7053, + 0x0006_500b, + 0x0013_3059, + 0x000a_d011, + 0x0046_941b, + 0x0016_70c5, + 0x0007_f00b, + 0x0008_3043, + 0x002f_52bd, + 0x000a_d097, + 0x0013_d00d, + 0x0033_b06b, + 0x004c_d35f, + 0x001f_7071, + 0x002f_9199, + 0x0018_5125, + 0x0057_7209, + 0x0015_b133, + 0x0002_b00d, + 0x000e_f0c5, + 0x0021_d1af, + 0x001d_f101, + 0x0035_9337, + 0x0019_9191, + 0x0001_f013, + 0x0013_306b, + 0x001c_d101, + 0x0011_508b, + 0x0011_900d, + 0x000e_3059, + 0x0008_3035, + 0x0049_3425, + 0x0025_917f, + 0x0023_903d, + 0x0016_10c7, + 0x000f_1011, + 0x0000_d007, + 0x000a_d04f, + 0x000e_30b3, + 0x000e_90c5, + 0x000c_503b, + 0x0017_b0c1, + 0x0010_f011, + 0x0017_b139, + 0x0013_d03d, + 0x0022_3119, + 0x0026_5097, + 0x0009_7089, + 0x001d_f199, + 0x0006_102b, + 0x0011_b025, + 0x0022_d053, + 0x0042_5281, + 0x003c_7049, + 0x000c_7011, + 0x0027_7089, + 0x000a_709d, + 0x000d_3003, + 0x0026_5151, + 0x0035_f161, + 0x0028_306d, + 0x0025_700d, + 0x0001_1005, + 0x0023_306b, + 0x001a_f0d3, + 0x001a_50b3, + 0x0010_1025, + 0x000b_5043, + 0x000e_300b, + 0x0017_f133, + 0x0018_d005, + 0x001f_d067, + 0x0012_50d3, + 0x0029_5007, + 0x001b_b095, + 0x0024_b23b, + 0x001f_7083, + 0x0026_b1c1, + 0x0036_d20b, + 0x0029_503d, + 0x0017_50a3, + 0x0005_3025, + 0x0029_315d, + 0x0002_b00d, + 0x0023_911b, + 0x0016_f0df, + 0x000e_907f, + 0x000e_9097, + 0x0019_101f, + 0x0051_74cf, + 0x0009_5035, + 0x001b_10c5, + 0x0058_f0c1, + 0x0020_b0e5, + 0x0012_50b5, + 0x0013_3053, + 0x0023_310f, + 0x0033_5305, + 0x002b_d161, + 0x0013_d003, + 0x0013_90a7, + 0x004c_d02f, + 0x0025_9013, + 0x0019_1119, + 0x000b_f00b, + 0x0052_707f, + 0x0017_b0b5, + 0x0010_d03d, + 0x001f_70ad, + 0x0000_7005, + 0x0010_70e5, + 0x0011_50f1, + 0x0015_10b3, + 0x001b_7061, + 0x003a_9283, + 0x0022_d0e3, + 0x001e_7125, + 0x003a_92a5, + 0x001e_b14b, + 0x0014_b043, + 0x0018_d10f, + 0x0021_d1af, + 0x0010_d011, + 0x0011_507f, + 0x0003_500b, + 0x0022_31bb, + 0x002f_5167, + 0x000c_702b, + 0x0027_71cf, + 0x0022_d02b, + 0x000e_f083, + 0x0016_f115, + 0x0017_b083, + 0x000e_f0a7, + 0x0015_100b, + 0x0008_902b, + 0x001c_10c1, + 0x0020_b0a3, + 0x003b_307f, + 0x0010_702f, + 0x0015_d06d, + 0x000f_1059, + 0x001a_f00b, + 0x0016_700d, + 0x001b_7043, + 0x005f_b0bf, + 0x001c_f043, + 0x0006_d01d, + 0x0013_d0ef, + 0x002a_5049, + 0x002c_f14b, + 0x001c_1043, + 0x0010_f01d, + 0x001c_91a5, + 0x0013_901d, + 0x0012_5067, + 0x0013_908b, + 0x0007_100d, + 0x0023_3185, + 0x001c_d013, + 0x003f_d043, + 0x0015_b101, + 0x000a_700d, + 0x0032_b281, + 0x001a_f0e5, + 0x0028_1107, + 0x0016_103b, + 0x0023_90e9, + 0x002e_7161, + 0x0019_1047, + 0x0008_3011, + 0x0006_1025, + 0x0010_d0f1, + 0x0031_3125, + 0x004e_b239, + 0x002a_503d, + 0x000e_50b5, + 0x0016_1047, + 0x0011_b03d, + 0x000e_3035, + 0x0016_7095, + 0x0013_30c5, + 0x0014_b005, + 0x0040_f397, + 0x0013_d03b, + 0x001c_1115, + 0x0041_931d, + 0x0010_f059, + 0x0000_b005, + 0x001a_5089, + 0x0003_5003, + 0x000c_70a3, + 0x0010_7083, + 0x0013_d029, + 0x0004_303b, + 0x0018_5161, + 0x000d_f00d, + 0x001c_9133, + 0x0025_f1c1, + 0x001c_9139, + 0x0016_f025, + 0x0025_1061, + 0x0038_b191, + 0x0044_30a7, + 0x005a_d4e1, + 0x0013_3035, + 0x001a_3065, + 0x000d_301d, + 0x000d_3017, + 0x000a_301f, + 0x0026_b14b, + 0x0010_f0b3, + 0x0048_13fd, + 0x0004_9035, + 0x000a_3097, + 0x000b_501f, + 0x001e_b119, + 0x0011_b10f, + 0x0021_d15d, + 0x0011_90c5, + 0x0017_b09d, + 0x006a_108b, + 0x0017_508b, + 0x0008_b083, + 0x000f_106d, + 0x0005_901d, + 0x0012_50bf, + 0x001c_f0c5, + 0x0022_3029, + 0x0008_b02f, + 0x0010_f10d, + 0x000b_500d, + 0x001a_f06d, + 0x0010_10b5, + 0x000e_3035, + 0x0004_300d, + 0x0006_1005, + 0x0006_b00d, + 0x000e_f03d, + 0x000d_f089, + 0x0006_101f, + 0x000c_5047, + 0x000d_306b, + 0x000f_10e9, + 0x001f_3047, + 0x003d_f18d, + 0x0008_904f, + 0x0027_70b5, + 0x0018_50f1, + 0x0017_5059, + 0x002b_d06b, + 0x0017_50d3, + 0x0022_d00d, + 0x001f_7003, + 0x0006_700d, + 0x0013_900d, + 0x0018_5107, + 0x0035_51d3, + 0x0023_3047, + 0x0004_9005, + 0x0015_d0a7, + 0x0030_5035, + 0x0017_b119, + 0x000a_3013, + 0x002b_d241, + 0x0003_b005, + 0x002e_72a1, + 0x0035_b11b, + 0x0011_b115, + 0x002c_506d, + 0x000f_100b, + 0x001f_d061, + 0x001d_f17b, + 0x0018_d0c5, + 0x002d_7061, + 0x0006_102b, + 0x000d_f0ad, + 0x000c_70a3, + 0x0010_7089, + 0x0025_7191, + 0x0027_700d, + 0x002d_d161, + 0x0008_b089, + 0x001c_d07f, + 0x0016_702b, + 0x0030_11b7, + 0x0033_7305, + 0x001c_91a3, + 0x002e_f20b, + 0x0013_d04f, + 0x0023_321d, + 0x0005_301f, + 0x0028_308b, + 0x0027_7065, + 0x0031_d251, + 0x0017_5011, + 0x0015_1071, + 0x002a_11b1, + 0x000d_303b, + 0x0032_904f, + 0x0023_b0c5, + 0x0011_b0e3, + 0x0006_500b, + 0x0025_7089, + 0x001f_d14b, + 0x0025_9061, + 0x001f_310f, + 0x0059_5529, + 0x004f_f2f5, + 0x0003_d035, + 0x000a_d00d, + 0x0010_704f, + 0x0001_100d, + 0x0015_1003, + 0x0026_5167, + 0x000d_f013, + 0x0028_324b, + 0x0009_5059, + 0x0028_306b, + 0x0030_1097, + 0x0011_5101, + 0x0036_d259, + 0x0015_110d, + 0x0019_9071, + 0x0023_90ef, + 0x002e_3175, + 0x002e_f277, + 0x0021_d1cf, + 0x000b_5043, + 0x0006_103b, + 0x0058_1061, + 0x0006_103d, + 0x0038_f251, + 0x0008_3059, + 0x0028_113d, + 0x000d_3059, + 0x0018_5047, + 0x0030_50c7, + 0x0016_102f, + 0x0029_515d, + 0x001f_30f1, + 0x001d_f025, + 0x002f_9259, + 0x0013_d11b, + 0x0028_317f, + 0x001a_30ef, + 0x0017_f061, + 0x002f_50a7, + 0x0015_d0bf, + 0x0030_5151, + 0x0013_303d, + 0x000e_9029, + 0x003b_322d, + 0x0000_d005, + 0x0006_d025, + 0x0017_f167, + 0x0051_b38f, + 0x0017_5005, + 0x0004_9011, + 0x001d_31cd, + 0x0006_5053, + 0x000c_70c1, + 0x001d_315b, + 0x0013_d0c7, + 0x0035_917b, + 0x0005_9053, + 0x0013_910f, + 0x000f_10c7, + 0x002d_d15d, + 0x001d_f097, + 0x0016_7061, + 0x000f_b059, + 0x0010_1049, + 0x000e_303d, + 0x0016_f049, + 0x0024_b1a5, + 0x000f_b0d3, + 0x0035_b277, + 0x0006_b047, + 0x003c_703d, + 0x001e_7199, + 0x0009_7047, + 0x0004_903d, + 0x0033_d1a5, + 0x001c_1185, + 0x000b_501f, + 0x0035_b0e3, + 0x001f_d017, + 0x0003_501d, + 0x0004_3017, + 0x003d_735b, + 0x000e_f00d, + 0x0008_300d, + 0x001b_7059, + 0x0036_d259, + 0x0051_743f, + 0x0048_1469, + 0x001d_3107, + 0x0044_f3df, + 0x002c_f22d, + 0x0009_7049, + 0x001f_d133, + 0x002e_30f1, + 0x002d_d16f, + 0x000d_f00d, + 0x0044_304f, + 0x000e_f061, + 0x0016_1025, + 0x000f_b013, + 0x000f_b0c1, + 0x001f_7167, + 0x0009_700b, + 0x0013_d11b, + 0x0004_9025, + 0x0019_9013, + 0x0025_706b, + 0x0023_30ad, + 0x002c_51a5, + 0x0055_71eb, + 0x0011_5061, + 0x0000_d007, + 0x0033_7251, + 0x0035_9065, + 0x0028_7137, + 0x000d_302f, + 0x0047_f449, + 0x000a_300d, + 0x001b_718d, + 0x0008_904f, + 0x003e_511b, + 0x0015_b137, + 0x000c_7095, + 0x0034_7199, + 0x000e_f089, + 0x000b_503b, + 0x0016_1013, + 0x003b_9115, + 0x0023_30e9, + 0x0006_d02b, + 0x0015_d061, + 0x0010_f083, + 0x0042_d377, + 0x0025_7223, + 0x002f_50e3, + 0x0027_71a3, + 0x0028_d03b, + 0x001a_508b, + 0x000f_10e9, + 0x001e_b097, + 0x0003_d03b, + 0x0031_3295, + 0x0051_103b, + 0x0044_f0b3, + 0x0029_5137, + 0x000e_f07f, + 0x0006_b01f, + 0x0035_5125, + 0x000a_3089, + 0x0010_10bf, + 0x001f_30e5, + 0x000b_5005, + 0x0033_51c1, + 0x0017_509d, + 0x0009_d071, + 0x001a_3007, + 0x0024_115d, + 0x0007_106d, + 0x0009_d089, + 0x0008_b02b, + 0x002f_901f, + 0x0026_5125, + 0x001e_b0e3, + 0x0018_d15d, + 0x0010_f00b, + 0x001a_517b, + 0x0004_f02f, + 0x0019_10e9, + 0x0026_5223, + 0x0008_b01d, + 0x0034_71cd, + 0x0007_f035, + 0x0019_9005, + 0x0028_d283, + 0x0010_f01d, + 0x0011_b119, + 0x001f_302f, + 0x0010_f067, + 0x000d_f017, + 0x000b_502b, + 0x000b_5029, + 0x0011_90df, + 0x0011_b01d, + 0x0016_1007, + 0x000a_309d, + 0x000f_10bf, + 0x0025_121d, + 0x0016_7071, + 0x0040_903d, + 0x000a_302f, + 0x0028_1233, + 0x001d_307f, + 0x002b_31a5, + 0x0024_1025, + 0x0035_9005, + 0x000d_307f, + 0x0008_903d, + 0x001e_b0fb, + 0x0016_703d, + 0x0013_3119, + 0x001c_1047, + 0x0034_709d, + 0x0011_b089, + 0x0008_3053, + 0x000d_f049, + 0x0006_501f, + 0x002e_f0ef, + 0x0015_10e5, + 0x0004_703b, + 0x002e_7119, + 0x0006_5043, + 0x0015_b0b5, + 0x0017_f0c7, + 0x002c_f241, + 0x0003_d005, + 0x002e_30ef, + 0x000e_30c1, + 0x0019_9115, + 0x0017_b053, + 0x0013_d0e9, + 0x0017_b14b, + 0x0044_92b3, + 0x0006_5013, + 0x0018_d02b, + 0x000c_50a3, + 0x0005_9053, + 0x0023_b00d, + 0x0030_51cf, + 0x000e_300d, + 0x0023_9151, + 0x001e_b10d, + 0x0026_b161, + 0x0013_30b5, + 0x0061_7265, + 0x000e_90d3, + 0x0018_d00b, + 0x0016_7071, + 0x0037_7089, + 0x0029_30df, + 0x0004_902f, + 0x003f_b025, + 0x0035_5277, + 0x001b_7035, + 0x0063_d371, + 0x0038_f1f7, + 0x0017_b07f, + 0x0012_506b, + 0x0006_5007, + 0x0017_5005, + 0x0038_b2f9, + 0x001c_f00d, + 0x0040_72f9, + 0x000f_b0e5, + 0x0021_d0d3, + 0x0024_b1e7, + 0x0020_b02b, + 0x0028_107f, + 0x0017_50e9, + 0x001f_717f, + 0x001c_10c7, + 0x003f_50bf, + 0x0023_b03b, + 0x0033_d17b, + 0x0021_d1f7, + 0x0027_7097, + 0x0021_d1b7, + 0x0023_90df, + 0x0008_3029, + 0x0010_700d, + 0x0017_f03d, + 0x0010_d0c1, + 0x002c_f043, + 0x0009_701f, + 0x0005_3029, + 0x0010_10e3, + 0x0055_12dd, + 0x0018_d013, + 0x0029_509d, + 0x0013_d083, + 0x0025_f0c7, + 0x003c_b3b3, + 0x000a_703d, + 0x0017_b13d, + 0x0034_7257, + 0x001f_d0c5, + 0x000a_d025, + 0x0025_f089, + 0x006a_d425, + 0x0035_b0c5, + 0x0012_500b, + 0x0007_100b, + 0x002e_f259, + 0x0032_b28d, + 0x0004_903d, + 0x001a_50e9, + 0x0017_50a7, + 0x0044_f335, + 0x0038_b33d, + 0x0002_b00d, + 0x0006_500d, + 0x003f_b065, + 0x0030_504f, + 0x0013_30d3, + 0x0024_b1af, + 0x0003_d03b, + 0x0006_d029, + 0x002d_d16f, + 0x0000_b005, + 0x001c_d06b, + 0x0008_b043, + 0x0028_7233, + 0x0025_915d, + 0x0019_106b, + 0x0051_50ad, + 0x0020_b095, + 0x001d_317f, + 0x0017_f11b, + 0x001b_b0e5, + 0x0007_100b, + 0x0009_d03b, + 0x0013_3029, + 0x001c_d0b5, + 0x001e_70e9, + 0x0010_709d, + 0x0026_b0f1, + 0x001c_d115, + 0x0003_5005, + 0x0003_500d, + 0x0016_708b, + 0x000a_7061, + 0x000b_3053, + 0x000e_5071, + 0x001e_b14b, + 0x0007_101f, + 0x001f_3003, + 0x0017_b047, + 0x0028_723b, + 0x000f_109d, + 0x0017_b03b, + 0x003b_90f1, + 0x000a_3029, + 0x000e_302b, + 0x000a_d09d, + 0x001d_31b1, + 0x001c_f08b, + 0x0008_3049, + 0x000c_700b, + 0x0048_11eb, + 0x003d_10e3, + 0x000a_d04f, + 0x000c_506d, + 0x000e_50bf, + 0x0038_f061, + 0x0018_517b, + 0x0013_7097, + 0x0003_5007, + 0x000b_f025, + 0x001f_71a5, + 0x0008_903b, + 0x000e_f0c5, + 0x0032_9175, + 0x0016_f10d, + 0x0025_f043, + 0x0027_7017, + 0x0023_b017, + 0x0028_304f, + 0x0033_72a5, + 0x0024_b035, + 0x001a_3101, + 0x0019_114b, + 0x0015_d04f, + 0x0009_d01d, + 0x0031_3097, + 0x0051_7011, + 0x0032_b125, + 0x0010_7065, + 0x0010_f08b, + 0x0029_5005, + 0x002b_324b, + 0x001c_d043, + 0x001e_b16f, + 0x0068_3577, + 0x000b_f005, + 0x0009_5005, + 0x001b_b025, + 0x0017_b017, + 0x0026_521d, + 0x000f_1053, + 0x0022_301d, + 0x0023_b011, + 0x0013_d007, + 0x003c_b02f, + 0x001a_f101, + 0x0024_b191, + 0x001b_b06d, + 0x0016_107f, + 0x0013_7029, + 0x0028_1035, + 0x0028_d007, + 0x001f_31bb, + 0x000e_500b, + 0x003a_d01d, + 0x001e_b0b3, + 0x0016_1013, + 0x0017_5125, + 0x0025_f241, + 0x000c_500d, + 0x0033_70a3, + 0x0011_b119, + 0x0023_9061, + 0x005f_b2ef, + 0x003b_3251, + 0x002c_5035, + 0x0010_703d, + 0x0000_d005, + 0x0033_723b, + 0x001d_f15d, + 0x0011_901d, + 0x0024_1137, + 0x0009_5013, + 0x0028_1083, + 0x001d_f137, + 0x0013_70b5, + 0x0031_d0b3, + 0x0010_d00d, + 0x001e_70c5, + 0x001c_9191, + 0x002a_1191, + 0x001e_70fb, + 0x0023_900b, + 0x0015_b035, + 0x000e_906d, + 0x001f_714b, + 0x000a_d04f, + 0x0042_50f1, + 0x002f_51e7, + 0x0025_f1a5, + 0x002e_3281, + 0x001c_913d, + 0x0020_b025, + 0x0021_d017, + 0x003a_d1bb, + 0x0055_12bd, + 0x000c_503d, + 0x0024_11cd, + 0x001c_90bf, + 0x007c_922d, + 0x001c_107f, + 0x0030_50b5, + 0x002e_7043, + 0x0007_f03d, + 0x001a_51a3, + 0x0019_111b, + 0x000a_d0a7, + 0x002d_7185, + 0x0002_901d, + 0x000c_500b, + 0x0026_900d, + 0x0018_503d, + 0x005b_3287, + 0x005b_f359, + 0x000c_5097, + 0x0050_923b, + 0x002b_323b, + 0x0004_901f, + 0x0037_1233, + 0x001c_10fb, + 0x0002_501f, + 0x000a_d08b, + 0x003d_f301, + 0x001e_b007, + 0x0028_11f3, + 0x003a_d059, + 0x0010_7011, + 0x0040_7251, + 0x0023_9097, + 0x0016_7151, + 0x0021_d0b5, + 0x0022_d1df, + 0x0016_7083, + 0x0008_901f, + 0x000c_7013, + 0x0018_d17b, + 0x0003_b029, + 0x001f_d0e5, + 0x0035_f0e5, + 0x0049_3125, + 0x0028_d277, + 0x0033_d199, + 0x001d_f1bb, + 0x0006_b047, + 0x0015_d0e5, + 0x000c_504f, + 0x002a_117f, + 0x000d_308b, + 0x0041_b1a5, + 0x001e_b06d, + 0x0017_514b, + 0x0012_50a7, + 0x0002_f025, + 0x001c_116f, + 0x0065_b4eb, + 0x001c_f151, + 0x001d_317b, + 0x0017_b0e5, + 0x001f_714b, + 0x0024_b1f7, + 0x000e_30b3, + 0x0026_b185, + 0x0010_700b, + 0x0028_3241, + 0x0017_f10d, + 0x0038_f06d, + 0x000c_502f, + 0x0029_525f, + 0x0024_1047, + 0x003a_90c1, + 0x0028_d0c1, + 0x0005_3047, + 0x0012_5083, + 0x0009_d047, + 0x0025_9167, + 0x0013_7049, + 0x0007_f04f, + 0x000e_f0a3, + 0x001d_30bf, + 0x0031_31c1, + 0x000e_30c7, + 0x0013_3107, + 0x0029_3223, + 0x0029_524b, + 0x0031_d0c7, + 0x0017_b139, + 0x0011_90e5, + 0x0005_9025, + 0x0029_50f1, + 0x0050_b0b3, + 0x001b_1185, + 0x0013_9013, + 0x0009_d01d, + 0x0007_100d, + 0x0017_b035, + 0x0049_344f, + 0x003b_3139, + 0x0006_b011, + 0x002d_d00d, + 0x0024_b089, + 0x001b_7095, + 0x0013_7047, + 0x0028_30fb, + 0x0002_9013, + 0x0011_903d, + 0x000d_3025, + 0x0016_1151, + 0x0023_301f, + 0x0027_725f, + 0x001c_1151, + 0x0008_9053, + 0x0001_100d, + 0x0027_71b1, + 0x0018_50c1, + 0x002f_91c1, + 0x002f_51fd, + 0x000c_5011, + 0x0010_103b, + 0x002c_5283, + 0x0026_5067, + 0x000b_f03d, + 0x002d_700b, + 0x0015_d125, + 0x0043_f419, + 0x003b_3269, + 0x0015_10b5, + 0x0013_700d, + 0x0017_f01d, + 0x001c_f185, + 0x000a_7059, + 0x0027_7191, + 0x0004_303d, + 0x002a_1293, + 0x001c_d0d3, + 0x001b_b115, + 0x0012_5061, + 0x0023_b22d, + 0x0015_1137, + 0x0010_1083, + 0x001f_30f1, + 0x0017_5053, + 0x0009_7025, + 0x0022_d0b3, + 0x0023_b13d, + 0x0002_f011, + 0x001a_515d, + 0x0011_b115, + 0x0011_906b, + 0x000e_5005, + 0x000e_90b3, + 0x004c_d0fb, + 0x002d_7089, + 0x001f_71a3, + 0x0006_b02f, + 0x0025_901d, + 0x0024_b0c7, + 0x000e_900b, + 0x001b_1139, + 0x001f_3107, + 0x002a_b083, + 0x001f_31df, + 0x0020_906d, + 0x0025_1061, + 0x0031_d137, + 0x0025_90fb, + 0x0031_d1bb, + 0x001e_b133, + 0x0019_9161, + 0x001f_71eb, + 0x001e_7007, + 0x001e_b089, + 0x0010_f005, + 0x000b_f083, + 0x0010_1095, + 0x0036_d335, + 0x002e_3223, + 0x001e_70ad, + 0x001f_303b, + 0x002e_f1a3, + 0x0006_b01f, + 0x002a_b1cd, + 0x000e_9005, + 0x004f_f455, + 0x000f_10b3, + 0x000b_506b, + 0x0014_b013, + 0x0013_7029, + 0x0033_b119, + 0x001a_3025, + 0x003a_d061, + 0x0028_10e9, + 0x0002_b025, + 0x001a_f125, + 0x0006_b025, + 0x000a_306d, + 0x000e_3067, + 0x001c_11b7, + 0x000b_5059, + 0x0006_b005, + 0x0025_7035, + 0x0023_b059, + 0x0020_90ad, + 0x0007_f02f, + 0x005e_747f, + 0x0016_7035, + 0x0012_506d, + 0x002d_715b, + 0x001c_9125, + 0x0022_30b5, + 0x0009_501f, + 0x0019_90c5, + 0x002f_9049, + 0x0019_1175, + 0x001c_900b, + 0x000e_f013, + 0x0020_90c1, + 0x001b_101d, + 0x0037_7251, + 0x004d_5301, + 0x000c_5047, + 0x001a_3025, + 0x000e_f061, + 0x002a_b23b, + 0x0015_103b, + 0x0010_f097, + 0x000d_3043, + 0x000a_702b, + 0x0051_71bb, + 0x0033_d32b, + 0x0010_f0e9, + 0x0010_70b5, + 0x0022_309d, + 0x0028_31b1, + 0x0003_b035, + 0x0016_f089, + 0x0028_31c1, + 0x0000_d005, + 0x0032_9005, + 0x0027_7083, + 0x0016_7005, + 0x0009_5007, + 0x0025_1199, + 0x0018_5101, + 0x000c_106d, + 0x0013_90b5, + 0x0017_50e3, + 0x0010_f083, + 0x001c_f03d, + 0x001f_70df, + 0x0036_d04f, + 0x0067_f185, + 0x0025_f047, + 0x001b_b065, + 0x001d_300d, + 0x0025_f101, + 0x000a_d03d, + 0x000b_3095, + 0x0004_f005, + 0x001c_90a3, + 0x0038_f1fd, + 0x0034_710d, + 0x0006_7017, + 0x0015_d00d, + 0x0013_30e5, + 0x0020_b133, + 0x002b_31b7, + 0x0022_d223, + 0x0025_90d3, + 0x0050_b035, + 0x0023_b125, + 0x0012_5059, + 0x000c_703b, + 0x000a_d00b, + 0x0017_5005, + 0x0036_d10d, + 0x000e_f095, + 0x0011_b10d, + 0x0013_300d, + 0x0011_b043, + 0x001d_f067, + 0x0013_302b, + 0x001f_d029, + 0x001a_5013, + 0x001c_d04f, + 0x0005_904f, + 0x000b_f061, + 0x0008_b005, + 0x000a_306b, + 0x001f_7097, + 0x001a_317b, + 0x002b_d13d, + 0x001d_f049, + 0x0000_d005, + 0x000a_d00d, + 0x002b_3277, + 0x001c_100b, + 0x0030_12f5, + 0x000a_d00d, + 0x000a_3059, + 0x0026_520b, + 0x0029_503d, + 0x0002_500b, + 0x000e_501f, + 0x002a_50b5, + 0x0018_504f, + 0x001a_f08b, + 0x0019_9175, + 0x004c_d427, + 0x0016_106d, + 0x0032_b265, + 0x001e_b059, + 0x0013_3101, + 0x0009_701d, + 0x0025_1119, + 0x0010_d01d, + 0x0015_d14b, + 0x0001_300d, + 0x002a_1287, + 0x0016_1025, + 0x003f_d371, + 0x0019_917f, + 0x001a_f0f1, + 0x0024_b00d, + 0x0019_9029, + 0x0035_b007, + 0x0013_d02b, + 0x0006_d03d, + 0x0020_b097, + 0x0064_d01d, + 0x0024_1191, + 0x001d_f18d, + 0x002e_f185, + 0x000b_f0b5, + 0x0025_f07f, + 0x0016_f0c7, + 0x001f_702b, + 0x003f_5139, + 0x001c_f0c1, + 0x0013_908b, + 0x000e_500d, + 0x000c_7005, + 0x0067_f31d, + 0x0036_d2f5, + 0x0023_31df, + 0x0009_7035, + 0x0025_713d, + 0x000c_1083, + 0x0013_30bf, + 0x004c_72ab, + 0x000c_100b, + 0x0025_1043, + 0x002e_3259, + 0x0037_102b, + 0x0038_b35f, + 0x0044_9277, + 0x0044_91f7, + 0x000b_3053, + 0x0045_d00b, + 0x0042_7359, + 0x0017_515d, + 0x0026_b0a3, + 0x002d_70e9, + 0x0011_50e5, + 0x0017_50c1, + 0x003d_f09d, + 0x0017_f03d, + 0x000e_f053, + 0x000f_b049, + 0x0020_9005, + 0x002b_d049, + 0x0045_d005, + 0x0011_b013, + 0x0002_500d, + 0x0055_7529, + 0x000c_701d, + 0x000b_3017, + 0x0015_d013, + 0x0024_b061, + 0x002a_51cd, + 0x0024_1199, + 0x000a_7065, + 0x0038_b33d, + 0x000d_3005, + 0x001f_70bf, + 0x003f_d2dd, + 0x000c_7071, + 0x0016_70f1, + 0x0006_5013, + 0x0004_3017, + 0x0035_f047, + 0x0015_10ef, + 0x0023_301d, + 0x0025_90e3, + 0x0006_d005, + 0x006a_1509, + 0x0004_701f, + 0x0006_5035, + 0x0008_9067, + 0x0035_f1e7, + 0x003f_b09d, + 0x0012_509d, + 0x002e_f251, + 0x0025_90bf, + 0x0031_3043, + 0x0009_502b, + 0x007b_5445, + 0x0025_1191, + 0x0001_300d, + 0x0061_f295, + 0x0028_71c9, + 0x000c_50bf, + 0x0010_f03b, + 0x000a_3025, + 0x0021_d025, + 0x0012_500b, + 0x000b_506b, + 0x001b_7061, + 0x0006_5013, + 0x002c_5097, + 0x003a_d0fb, + 0x0037_72f9, + 0x001f_71e7, + 0x001e_7003, + 0x0024_b1b1, + 0x0007_f029, + 0x001a_f0df, + 0x001a_5095, + 0x0016_f00d, + 0x001c_d09d, + 0x0026_5013, + 0x003c_7151, + 0x0017_b101, + 0x000a_d047, + 0x000b_301f, + 0x0016_f101, + 0x0015_b061, + 0x0014_b11b, + 0x004a_3115, + 0x0006_5005, + 0x0002_500d, + 0x0004_7005, + 0x0015_10b5, + 0x000f_b0c1, + 0x0038_b2c5, + 0x0026_909d, + 0x0002_5003, + 0x000b_f011, + 0x000b_f095, + 0x000e_9071, + 0x0016_f161, + 0x0028_3013, + 0x0026_b15b, + 0x0038_f301, + 0x0015_d0e9, + 0x003b_9035, + 0x0015_b043, + 0x004f_f36d, + 0x0012_511b, + 0x0007_f029, + 0x0016_702b, + 0x0025_7071, + 0x0025_703d, + 0x0050_b427, + 0x002e_315d, + 0x001c_d0a7, + 0x0020_91af, + 0x0002_501d, + 0x0025_7125, + 0x0009_700d, + 0x001b_1067, + 0x0025_91cf, + 0x0023_b01d, + 0x000c_506b, + 0x0024_b065, + 0x002e_f185, + 0x001e_7013, + 0x0004_9007, + 0x0023_9119, + 0x002d_d059, + 0x004c_d40f, + 0x000f_1029, + 0x004c_d287, + 0x0031_d26b, + 0x002f_92a5, + 0x002e_f28d, + 0x0016_70ef, + 0x003e_5329, + 0x0023_b161, + 0x0033_72dd, + 0x0017_515d, + 0x001d_f1a3, + 0x0016_f047, + 0x0012_50b3, + 0x003a_11d3, + 0x001a_306b, + 0x0002_b00d, + 0x001c_f065, + 0x0013_30b3, + 0x001e_b17b, + 0x0029_526b, + 0x0025_7199, + 0x0013_d005, + 0x000b_f00b, + 0x0022_3151, + 0x0023_3097, + 0x001e_b15b, + 0x0033_d2ef, + 0x0010_d0ef, + 0x0033_5095, + 0x0025_7095, + 0x003e_5053, + 0x0003_d02b, + 0x000e_908b, + 0x001d_3047, + 0x0015_b053, + 0x0022_31f7, + 0x0011_9043, + 0x003c_7059, + 0x005f_31fd, + 0x0023_b01d, + 0x0010_f02f, + 0x0033_b06d, + 0x0009_7005, + 0x0007_f03b, + 0x0008_3035, + 0x0043_f277, + 0x0010_f017, + 0x000a_7083, + 0x0009_d061, + 0x0033_d035, + 0x000c_7061, + 0x0017_50b5, + 0x0037_7305, + 0x0010_7061, + 0x0023_30c7, + 0x0018_510f, + 0x0026_b0e5, + 0x0013_7089, + 0x0017_507f, + 0x0033_b049, + 0x0010_f0df, + 0x0052_706d, + 0x0024_1025, + 0x000a_7067, + 0x0023_b119, + 0x001c_1125, + 0x0011_502f, + 0x0037_71a5, + 0x0031_3287, + 0x0041_9007, + 0x0009_703d, + 0x0040_9397, + 0x000d_3049, + 0x0032_9097, + 0x0008_3005, + 0x001a_306d, + 0x002e_720b, + 0x0008_b083, + 0x0015_d0e3, + 0x000e_5071, + 0x0006_5059, + 0x002f_5151, + 0x0019_1101, + 0x000a_7095, + 0x0034_70a3, + 0x0012_5107, + 0x0009_5011, + 0x005d_b061, + 0x001c_1119, + 0x0033_700d, + 0x0016_7125, + 0x0015_d02b, + 0x001c_9043, + 0x002f_50e3, + 0x001d_f0b5, + 0x000f_b011, + 0x0033_d1c1, + 0x0029_325f, + 0x001f_d00d, + 0x000c_50ad, + 0x0025_900d, + 0x0012_500b, + 0x0011_504f, + 0x0005_300d, + 0x0031_3241, + 0x0017_5003, + 0x001f_30e9, + 0x0015_b025, + 0x001c_f007, + 0x001f_d18d, + 0x002c_f17b, + 0x0030_5043, + 0x0040_73f1, + 0x003b_3241, + 0x0016_70e3, + 0x004f_f089, + 0x0023_3043, + 0x0023_b035, + 0x002e_f15b, + 0x0018_5101, + 0x0065_b611, + 0x002e_326b, + 0x0027_70fb, + 0x0017_f005, + 0x0006_5025, + 0x0026_5137, + 0x0011_50bf, + 0x000f_100d, + 0x001b_1061, + 0x0011_b03d, + 0x0009_5049, + 0x0028_3059, + 0x000a_301d, + 0x0003_d01f, + 0x0017_f16f, + 0x0013_710f, + 0x0001_700d, + 0x0028_70ad, + 0x001a_302b, + 0x0050_31cf, + 0x0016_10b3, + 0x0020_9089, + 0x0002_501d, + 0x0005_9053, + 0x0011_b0e3, + 0x0033_72a1, + 0x000c_5005, + 0x0018_d185, + 0x001e_70bf, + 0x0010_103d, + 0x000e_50ad, + 0x0047_f0bf, + 0x0015_d14b, + 0x002f_9025, + 0x0011_b0ef, + 0x0037_71bb, + 0x0023_315d, + 0x0011_b0a3, + 0x001f_3005, + 0x0022_3071, + 0x0004_f01d, + 0x001f_d005, + 0x0015_1043, + 0x0009_5007, + 0x0014_b083, + 0x0036_d06d, + 0x0011_b0bf, + 0x0021_d01f, + 0x0003_d00b, + 0x0015_b0b3, + 0x0002_b01f, + 0x0007_106b, + 0x0040_7397, + 0x0009_7035, + 0x0007_1049, + 0x0051_1269, + 0x0028_3161, + 0x001d_f191, + 0x003a_d125, + 0x0055_10c1, + 0x0016_1115, + 0x0024_10fb, + 0x002e_7101, + 0x0014_b01d, + 0x0031_d209, + 0x0009_d003, + 0x000f_1053, + 0x0008_907f, + 0x0023_9095, + 0x0002_9005, + 0x003a_918d, + 0x0028_d0c1, + 0x0002_b01d, + 0x0036_d071, + 0x0009_503d, +]; + +//////////////////// Lookup tables for number theoretic functions + +// table for riemann zeta function. ZETA_LOG_TABLE[i] = ln(ζ(i-2)) +#[cfg(feature = "big-table")] +pub const ZETA_LOG_TABLE: [f64; 64] = [ + 4.977_003_024_707_453_7e-1, + 1.840_341_753_914_914_2e-1, + 7.910_987_306_733_563e-2, + 3.626_225_964_922_792e-2, + 1.719_438_760_265_829e-2, + 8.314_614_969_275_205e-3, + 4.069_066_307_412_955e-3, + 2.006_378_701_528_290_4e-3, + 9.940_808_656_690_608e-4, + 4.940_665_331_469_77e-4, + 2.460_562_789_788_238_5e-4, + 1.227_058_189_115_578_4e-4, + 6.124_625_946_826_463e-5, + 3.058_776_849_645_995e-5, + 1.528_214_263_611_525_4e-5, + 7.637_168_474_654_366e-6, + 3.817_285_979_154_446e-6, + 1.908_210_895_918_369_2e-6, + 9.539_615_788_513_044e-7, + 4.769_328_730_553_057e-7, + 2.384_504_742_984_163_7e-7, + 1.192_199_188_586_162_5e-7, + 5.960_818_727_469_145e-8, + 2.980_350_307_052_788e-8, + 1.490_155_471_733_687_4e-8, + 7.450_711_762_078_877e-9, + 3.725_334_017_849_400_4e-9, + 1.862_659_721_778_298_4e-9, + 9.313_274_319_859_827e-10, + 4.656_629_063_949_574e-10, + 2.328_311_833_405_454e-10, + 1.164_155_017_202_289e-10, + 5.820_772_087_733_294e-11, + 2.910_385_044_454_748e-11, + 1.455_192_189_093_610_6e-11, + 7.275_959_835_031_012e-12, + 3.637_979_547_372_033_4e-12, + 1.818_989_650_305_411_7e-12, + 9.094_947_840_259_753e-13, + 4.547_473_783_041_12e-13, + 2.273_736_845_824_394e-13, + 1.136_868_407_680_163_3e-13, + 5.684_341_987_627_424e-14, + 2.842_170_976_889_261_6e-14, + 1.421_085_482_803_150_7e-14, + 7.105_427_395_210_827e-15, + 3.552_713_691_337_108e-15, + 1.776_356_843_579_119e-15, + 8.881_784_210_930_812e-16, + 4.440_892_103_143_812e-16, + 2.220_446_050_798_042e-16, + 1.110_223_025_141_066_1e-16, + 5.551_115_124_845_481e-17, + 2.775_557_562_136_124e-17, + 1.387_778_780_972_523_2e-17, + 6.938_893_904_544_153e-18, + 3.469_446_952_165_922_5e-18, + 1.734_723_476_047_576_5e-18, + 8.673_617_380_119_933e-19, + 4.336_808_690_020_651e-19, + 2.168_404_344_997_22e-19, + 1.084_202_172_494_241_4e-19, + 5.421_010_862_456_646e-20, + 2.710_505_431_223_469e-20, +]; + +// tables for moebius function with small input +pub const MOEBIUS_ODD: [u64; 4] = [ + 0x4289_108a_0520_8102, + 0x1998_8004_a8a1_2422, + 0x1a82_4502_8906_a062, + 0x2294_2801_2aa2_6a00, +]; + +//////////////////// Prime gaps for prime indexing //////////////////// + +/* Code to generate wheel offsets: +```python +import numpy as np +wheel = [2,3,5] +wheel_size = np.product(wheel) +flags = np.ones(wheel_size, dtype=bool) +tester = np.arange(wheel_size) +for p in wheel: + flags[tester % p == 0] = False +flags = np.concatenate([flags, flags]) +next_table = np.zeros(wheel_size, dtype=int) +prev_table = np.zeros(wheel_size, dtype=int) +for i in range(wheel_size): + next_table[i] = np.argmax(flags[i:]) + prev_table[i] = np.argmax(flags[:wheel_size+i+1][::-1]) + +next_zeros, = np.where(next_table == 0) +next_table[next_zeros] = next_table[(next_zeros+1) % wheel_size]+1 +prev_zeros, = np.where(prev_table == 0) +prev_table[prev_zeros] = prev_table[(prev_zeros-1) % wheel_size]+1 + +print(next_table) +print(prev_table) +``` +*/ + +// offset for moving to the prev/next prime candidate on wheel30 (2*3*5) +#[cfg(not(feature = "big-table"))] +pub const WHEEL_SIZE: u8 = 30; +#[cfg(not(feature = "big-table"))] +pub const WHEEL_NEXT: [u8; 30] = [ + 1, 6, 5, 4, 3, 2, 1, 4, 3, 2, 1, 2, 1, 4, 3, 2, 1, 2, 1, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 2, +]; +#[cfg(not(feature = "big-table"))] +pub const WHEEL_PREV: [u8; 30] = [ + 1, 2, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 1, 2, 1, 2, 3, 4, 1, 2, 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, +]; + +// offset for moving to the prev/next prime candidate on wheel2310 (2*3*5*7*11) +#[cfg(feature = "big-table")] +pub const WHEEL_SIZE: u16 = 2310; +#[cfg(feature = "big-table")] +pub const WHEEL_NEXT: [u8; 2310] = [ + 1, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 4, 3, 2, 1, 2, 1, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 2, 1, + 6, 5, 4, 3, 2, 1, 4, 3, 2, 1, 2, 1, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 2, 1, 6, 5, + 4, 3, 2, 1, 4, 3, 2, 1, 2, 1, 6, 5, 4, 3, 2, 1, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 8, 7, 6, 5, 4, 3, + 2, 1, 4, 3, 2, 1, 2, 1, 4, 3, 2, 1, 2, 1, 4, 3, 2, 1, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, + 2, 1, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 2, 1, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 2, 1, 6, 5, 4, 3, 2, + 1, 6, 5, 4, 3, 2, 1, 4, 3, 2, 1, 2, 1, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 2, 1, 10, 9, 8, 7, 6, 5, + 4, 3, 2, 1, 2, 1, 4, 3, 2, 1, 2, 1, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 10, 9, 8, 7, 6, 5, + 4, 3, 2, 1, 2, 1, 4, 3, 2, 1, 2, 1, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 2, 1, 6, 5, 4, 3, 2, 1, 4, 3, + 2, 1, 6, 5, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 2, 1, 6, 5, 4, 3, 2, 1, 4, 3, 2, 1, + 2, 1, 6, 5, 4, 3, 2, 1, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 8, 7, 6, 5, 4, 3, 2, 1, 4, 3, 2, 1, 2, 1, + 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 8, 7, 6, 5, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 10, 9, 8, 7, 6, 5, 4, + 3, 2, 1, 2, 1, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 2, 1, 6, 5, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 4, 3, 2, + 1, 2, 1, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 2, 1, 6, 5, 4, 3, 2, 1, 4, 3, 2, 1, 2, 1, 6, 5, 4, 3, 2, + 1, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 2, 1, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 2, 1, 4, 3, 2, 1, 2, 1, + 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 8, 7, 6, 5, 4, 3, 2, 1, 4, 3, 2, 1, 2, 1, 4, 3, 2, 1, 12, 11, 10, + 9, 8, 7, 6, 5, 4, 3, 2, 1, 2, 1, 6, 5, 4, 3, 2, 1, 4, 3, 2, 1, 2, 1, 6, 5, 4, 3, 2, 1, 4, 3, 2, + 1, 6, 5, 4, 3, 2, 1, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 2, 1, 4, 3, 2, 1, 2, 1, 4, 3, 2, 1, + 8, 7, 6, 5, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 2, 1, 4, 3, 2, 1, 6, 5, + 4, 3, 2, 1, 2, 1, 6, 5, 4, 3, 2, 1, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 2, 1, 4, 3, 2, 1, 6, 5, 4, + 3, 2, 1, 2, 1, 6, 5, 4, 3, 2, 1, 4, 3, 2, 1, 2, 1, 4, 3, 2, 1, 2, 1, 10, 9, 8, 7, 6, 5, 4, 3, + 2, 1, 2, 1, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 2, 1, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 6, 5, 4, 3, 2, + 1, 2, 1, 6, 5, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 2, + 1, 6, 5, 4, 3, 2, 1, 4, 3, 2, 1, 2, 1, 6, 5, 4, 3, 2, 1, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 8, 7, 6, + 5, 4, 3, 2, 1, 4, 3, 2, 1, 2, 1, 6, 5, 4, 3, 2, 1, 4, 3, 2, 1, 8, 7, 6, 5, 4, 3, 2, 1, 6, 5, 4, + 3, 2, 1, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 2, 1, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 8, 7, 6, 5, 4, 3, 2, + 1, 6, 5, 4, 3, 2, 1, 4, 3, 2, 1, 2, 1, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 2, 1, 6, 5, 4, 3, 2, 1, + 4, 3, 2, 1, 2, 1, 4, 3, 2, 1, 2, 1, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 2, 1, 10, 9, 8, 7, 6, 5, 4, + 3, 2, 1, 2, 1, 4, 3, 2, 1, 2, 1, 4, 3, 2, 1, 8, 7, 6, 5, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 4, 3, 2, + 1, 2, 1, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 2, 1, 6, 5, 4, 3, 2, 1, 4, 3, 2, 1, 8, + 7, 6, 5, 4, 3, 2, 1, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 8, 7, 6, 5, 4, 3, 2, 1, 4, 3, 2, 1, 2, 1, 4, + 3, 2, 1, 2, 1, 4, 3, 2, 1, 8, 7, 6, 5, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 4, 3, 2, 1, 6, 5, 4, 3, 2, + 1, 6, 5, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 2, 1, 6, 5, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 4, 3, 2, 1, 2, + 1, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 2, 1, 6, 5, 4, 3, 2, 1, 4, 3, 2, 1, 2, 1, 4, 3, 2, 1, 2, 1, + 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 2, 1, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 2, 1, 6, 5, 4, 3, 2, 1, 4, + 3, 2, 1, 6, 5, 4, 3, 2, 1, 2, 1, 6, 5, 4, 3, 2, 1, 4, 3, 2, 1, 2, 1, 4, 3, 2, 1, 6, 5, 4, 3, 2, + 1, 6, 5, 4, 3, 2, 1, 8, 7, 6, 5, 4, 3, 2, 1, 4, 3, 2, 1, 2, 1, 6, 5, 4, 3, 2, 1, 10, 9, 8, 7, + 6, 5, 4, 3, 2, 1, 8, 7, 6, 5, 4, 3, 2, 1, 4, 3, 2, 1, 2, 1, 4, 3, 2, 1, 2, 1, 4, 3, 2, 1, 8, 7, + 6, 5, 4, 3, 2, 1, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 2, 1, 4, 3, 2, 1, 8, 7, 6, + 5, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 4, 3, 2, 1, 2, 1, 4, 3, 2, 1, 6, 5, 4, 3, 2, + 1, 2, 1, 6, 5, 4, 3, 2, 1, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 2, 1, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, + 2, 1, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 2, 1, 4, 3, 2, 1, 2, 1, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 2, + 1, 6, 5, 4, 3, 2, 1, 4, 3, 2, 1, 2, 1, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 2, 1, 6, + 5, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 8, 7, 6, 5, 4, + 3, 2, 1, 4, 3, 2, 1, 2, 1, 4, 3, 2, 1, 2, 1, 4, 3, 2, 1, 8, 7, 6, 5, 4, 3, 2, 1, 6, 5, 4, 3, 2, + 1, 4, 3, 2, 1, 8, 7, 6, 5, 4, 3, 2, 1, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 2, 1, 6, 5, 4, 3, 2, 1, 6, + 5, 4, 3, 2, 1, 4, 3, 2, 1, 2, 1, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 8, 7, 6, 5, 4, 3, 2, 1, 4, 3, 2, + 1, 2, 1, 4, 3, 2, 1, 2, 1, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 2, 1, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, + 2, 1, 4, 3, 2, 1, 2, 1, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 2, 1, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 2, + 1, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 8, 7, 6, 5, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 4, 3, 2, 1, 2, 1, 6, + 5, 4, 3, 2, 1, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 8, 7, 6, 5, 4, 3, 2, 1, 4, 3, 2, 1, 6, 5, 4, 3, 2, + 1, 2, 1, 4, 3, 2, 1, 8, 7, 6, 5, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 2, + 1, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 2, 1, 6, 5, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 4, 3, 2, 1, 6, 5, 4, + 3, 2, 1, 6, 5, 4, 3, 2, 1, 2, 1, 6, 5, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 4, 3, 2, 1, 2, 1, 10, 9, + 8, 7, 6, 5, 4, 3, 2, 1, 2, 1, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 2, 1, 4, 3, 2, 1, 2, 1, 4, 3, 2, + 1, 6, 5, 4, 3, 2, 1, 2, 1, 6, 5, 4, 3, 2, 1, 4, 3, 2, 1, 2, 1, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, + 6, 5, 4, 3, 2, 1, 2, 1, 6, 5, 4, 3, 2, 1, 4, 3, 2, 1, 2, 1, 6, 5, 4, 3, 2, 1, 4, 3, 2, 1, 6, 5, + 4, 3, 2, 1, 8, 7, 6, 5, 4, 3, 2, 1, 4, 3, 2, 1, 2, 1, 4, 3, 2, 1, 2, 1, 12, 11, 10, 9, 8, 7, 6, + 5, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 2, 1, 4, 3, 2, 1, 6, 5, 4, 3, 2, + 1, 2, 1, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 4, 3, 2, 1, 2, 1, 4, 3, 2, 1, 8, 7, 6, 5, 4, 3, + 2, 1, 6, 5, 4, 3, 2, 1, 4, 3, 2, 1, 2, 1, 4, 3, 2, 1, 2, 1, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 2, + 1, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 2, 1, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 2, 1, + 6, 5, 4, 3, 2, 1, 4, 3, 2, 1, 2, 1, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 2, 1, 6, 5, + 4, 3, 2, 1, 4, 3, 2, 1, 2, 1, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 8, 7, 6, 5, 4, + 3, 2, 1, 6, 5, 4, 3, 2, 1, 4, 3, 2, 1, 2, 1, 4, 3, 2, 1, 8, 7, 6, 5, 4, 3, 2, 1, 6, 5, 4, 3, 2, + 1, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 2, 1, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 2, 1, 6, 5, 4, 3, 2, 1, 6, + 5, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 2, 1, 6, 5, 4, 3, 2, 1, 4, 3, 2, + 1, 2, 1, 4, 3, 2, 1, 2, 1, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, + 1, 2, 1, 4, 3, 2, 1, 2, 1, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 2, 1, 6, 5, 4, 3, 2, 1, 4, 3, 2, 1, + 2, 1, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 2, 1, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 2, + 1, 6, 5, 4, 3, 2, 1, 4, 3, 2, 1, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 4, 3, 2, 1, 2, + 1, 4, 3, 2, 1, 2, 1, 4, 3, 2, 1, 8, 7, 6, 5, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 4, 3, 2, 1, 6, 5, 4, + 3, 2, 1, 2, 1, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 2, 1, 6, 5, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 4, 3, 2, + 1, 2, 1, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 2, 1, 6, 5, 4, 3, 2, 1, 4, 3, 2, 1, 2, 1, 4, 3, 2, 1, + 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 2, +]; +#[cfg(feature = "big-table")] +pub const WHEEL_PREV: [u8; 2310] = [ + 1, 2, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 1, 2, 3, 4, 1, 2, 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, 1, + 2, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 1, 2, 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 1, + 2, 3, 4, 5, 6, 1, 2, 3, 4, 1, 2, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, + 6, 7, 8, 1, 2, 3, 4, 1, 2, 1, 2, 3, 4, 1, 2, 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, + 13, 14, 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, 1, 2, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 1, 2, 3, 4, 5, + 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 1, 2, 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, 1, 2, 1, 2, 3, 4, 5, 6, 7, + 8, 9, 10, 1, 2, 1, 2, 3, 4, 1, 2, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 1, 2, 3, 4, 5, 6, 7, + 8, 9, 10, 1, 2, 1, 2, 3, 4, 1, 2, 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, 1, 2, 1, 2, 3, 4, 5, 6, 1, 2, + 3, 4, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, + 1, 2, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 1, 2, + 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 7, 8, + 9, 10, 1, 2, 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, 1, 2, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, + 4, 1, 2, 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, 1, 2, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 1, 2, 1, 2, 3, 4, 5, + 6, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 1, 2, 3, 4, 1, 2, + 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 1, 2, 1, 2, 3, 4, 1, 2, 3, 4, + 5, 6, 7, 8, 9, 10, 11, 12, 1, 2, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 1, 2, 1, 2, 3, 4, 5, 6, 1, 2, 3, + 4, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 1, 2, 1, 2, 3, 4, 1, 2, 1, 2, 3, 4, + 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, 1, 2, 1, 2, 3, 4, 1, 2, + 3, 4, 5, 6, 1, 2, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 1, 2, 3, 4, 1, 2, 3, + 4, 5, 6, 1, 2, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 1, 2, 1, 2, 3, 4, 1, 2, 1, 2, 3, 4, 5, 6, 7, 8, 9, + 10, 1, 2, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, + 1, 2, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, + 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 1, 2, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, + 5, 6, 7, 8, 1, 2, 3, 4, 1, 2, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, + 5, 6, 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, 1, 2, 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 7, 8, + 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 1, 2, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 1, 2, 3, 4, 5, 6, 1, + 2, 3, 4, 1, 2, 1, 2, 3, 4, 1, 2, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 1, 2, 3, 4, 5, 6, 7, 8, + 9, 10, 1, 2, 1, 2, 3, 4, 1, 2, 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 1, 2, 3, + 4, 1, 2, 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 1, + 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 1, 2, 1, + 2, 3, 4, 1, 2, 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 1, 2, 3, 4, 5, + 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 1, + 2, 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, 1, 2, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 1, 2, 1, 2, 3, 4, 1, 2, 1, + 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 1, 2, 3, 4, 5, 6, 1, 2, + 3, 4, 1, 2, 3, 4, 5, 6, 1, 2, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 1, 2, 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, + 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 1, 2, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, + 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 1, 2, 1, 2, 3, 4, 1, 2, 1, 2, 3, 4, 1, 2, 3, + 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 1, 2, 1, 2, 3, 4, 1, 2, 3, 4, + 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 1, 2, 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, + 1, 2, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, 1, 2, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, + 2, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 1, 2, 3, 4, 1, 2, 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, 1, 2, + 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 1, 2, 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 1, 2, + 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, + 7, 8, 1, 2, 3, 4, 1, 2, 1, 2, 3, 4, 1, 2, 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, + 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, 1, 2, 1, 2, 3, 4, 5, 6, 1, 2, + 3, 4, 5, 6, 1, 2, 3, 4, 1, 2, 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, + 1, 2, 1, 2, 3, 4, 1, 2, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, + 2, 1, 2, 3, 4, 1, 2, 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, 1, 2, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, + 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 1, 2, 1, 2, + 3, 4, 5, 6, 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, + 1, 2, 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, 1, 2, + 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, 1, 2, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 1, 2, 3, 4, + 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 1, 2, 1, 2, 3, 4, + 5, 6, 7, 8, 9, 10, 1, 2, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 1, 2, 3, 4, 1, 2, 1, 2, 3, 4, 1, + 2, 3, 4, 5, 6, 1, 2, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 1, 2, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, + 3, 4, 5, 6, 1, 2, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 1, 2, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 1, 2, 3, 4, + 5, 6, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 1, 2, 1, 2, 3, 4, 1, 2, 1, 2, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, 1, 2, 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, + 1, 2, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 1, 2, 3, 4, 1, 2, 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, 7, + 8, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 1, 2, 1, 2, 3, 4, 1, 2, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 1, 2, 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, 1, 2, 1, + 2, 3, 4, 5, 6, 1, 2, 3, 4, 1, 2, 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 1, 2, 3, + 4, 5, 6, 1, 2, 3, 4, 1, 2, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, + 7, 8, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 1, 2, 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, + 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, 1, 2, 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, 1, 2, 1, 2, 3, 4, 5, 6, 1, 2, + 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, 1, 2, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, + 1, 2, 1, 2, 3, 4, 1, 2, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, + 1, 2, 1, 2, 3, 4, 1, 2, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 1, + 2, 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, + 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 1, 2, 3, 4, 1, 2, + 1, 2, 3, 4, 1, 2, 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 1, 2, 3, 4, + 5, 6, 1, 2, 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, 1, 2, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, + 1, 2, 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, 1, 2, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 1, 2, 1, 2, 3, 4, 1, 2, + 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, +]; + +//////////////////// Modulo tables for fast perfect power check //////////////////// +/* Code to generate residuals: +```python +import math +import numpy as np + +N = 8 # number of modulus to be selected +LIM = 1024 # limit of modulus +fn = lambda x: x*x # power function + +# first select N modulus under LIM (assuming factor 2 is already considered) +frequency = [(len(np.unique([fn(i)%L for i in range(L)]))/L, L) + for L in range(1, LIM, 2)] +selections = [] +select_freq = 1 +for (f, n) in sorted(frequency): + for s in selections: + if math.gcd(n, s) != 1: + break + else: + selections.append(n) + select_freq *= f + if len(selections) >= N: + break + +print("Moduli:", selections) +print("Possibility", select_freq) + +# Then generate bit masks for the numbers +for s in selections: + bits = [0] * (s // 64 + 1) + for i in range(s): + ii = fn(i) % s + bits[ii//64] |= 1 << (ii%64) + print("Masks for", s, ":", ['0x%016x' % b for b in bits]) +``` +*/ + +#[cfg(all(not(feature = "big-table"), feature = "big-int"))] +pub const QUAD_MODULI: [u8; 4] = [63, 65, 61, 59]; // note that 0 and 64 are both square mod 65 +#[cfg(all(not(feature = "big-table"), feature = "big-int"))] +pub const QUAD_RESIDUAL: [u64; 4] = [ + 0x0402483012450293, + 0x218a019866014613, + 0x1713e6940a59f23b, + 0x022b62183e7b92bb, +]; + +#[cfg(all(not(feature = "big-table"), feature = "big-int"))] +pub const CUBIC_MODULI: [u8; 4] = [63, 61, 43, 37]; +#[cfg(all(not(feature = "big-table"), feature = "big-int"))] +pub const CUBIC_RESIDUAL: [u64; 4] = [ + 0x4080001818000103, + 0x1434026619900b0b, + 0x0000068908610917, + 0x00000010ac804d43, +]; + +#[cfg(all(feature = "big-table", feature = "big-int"))] +pub const QUAD_MODULI: [u16; 8] = [819, 935, 989, 899, 1007, 1021, 1019, 1013]; +#[rustfmt::skip] +#[cfg(all(feature = "big-table", feature = "big-int"))] +pub const QUAD_RESIDUAL: [[u64; 16]; 8] = [ + [0x0002_0810_0241_0213, 0xc200_0010_0902_8001, 0x0000_1200_0001_4024, 0x0080_4802_0208_a050, 0x1800_0482_0024_4029, 0x0420_1201_8002_0014, 0x2600_0000_8049_0408, 0x9100_0410_6020_0800, 0x0904_0048_0012_0100, 0x2402_0004_0008_2201, 0x4021_0092_0c00_0040, 0x0820_8040_0200_4880, 0x0000_0024_0301_2000, 0, 0, 0], + [0x1882_0014_0601_8213, 0x0288_c110_0242_0065, 0x8208_4640_0c01_0180, 0x4841_1422_3000_0010, 0x8004_000e_0110_0101, 0x00c0_4218_0128_0810, 0x1304_2021_0401_8060, 0xe400_8230_1400_1088, 0x0422_8001_100a_4000, 0x00c2_3144_008c_0401, 0x0100_0110_8320_4400, 0x1000_2410_8e00_1802, 0x2200_c002_0845_2040, 0x0031_0020_080c_0204, 0x0000_0000_0014_0210, 0], + [0x0c52_8218_8381_2253, 0x9220_4031_9082_4001, 0x1e00_26b0_0445_5c20, 0xa040_d1c2_09a5_8032, 0x298a_6842_0480_a049, 0x1003_0266_1200_0074, 0x6b80_48c4_0019_2281, 0x3001_02d8_0214_20a0, 0x8521_1508_223e_0404, 0x220a_8108_4580_0181, 0xcc50_2910_7051_0060, 0x8405_1352_0a40_8200, 0xd0a6_4220_48d3_8098, 0x0008_3c21_12b0_0305, 0x990d_8401_5102_20b4, 0x0000_0000_0140_0682], + [0xc80a_205a_1211_02b3, 0x2201_a890_6087_4089, 0x4890_e220_0121_1412, 0x9120_328e_0800_1414, 0xcd40_0a82_5a00_1c43, 0x6330_0228_30e0_8151, 0x169c_9048_3ca1_2044, 0x0416_2010_0262_0801, 0x4081_490e_008b_8218, 0xc422_4043_2812_2401, 0x711e_8810_8834_0820, 0x0946_3224_1a03_4000, 0x0201_29c8_0021_cb00, 0x2040_3862_0200_e624, 0, 0], + [0xc242_9c50_1303_0ad3, 0x0a89_0459_a006_2015, 0x1801_9308_c361_404c, 0x5100_2032_0520_42b8, 0x00b2_6046_0409_8505, 0x3614_a640_0cc0_4390, 0x022c_0384_8101_900d, 0x0220_5052_1208_7021, 0x4580_4800_ab06_11a6, 0x110a_0811_0156_680b, 0x10a7_2415_0200_38c8, 0xc061_1464_2ac0_0401, 0x0180_0034_9817_1808, 0x4c20_0101_2890_8622, 0x0c58_0602_0071_4052, 0x0000_0025_0004_0682], + [0x718b_b652_2e93_da3b, 0x6a5e_1518_1aeb_cef9, 0x5cb9_03b8_072b_20b4, 0xebb9_6e0b_5e64_f6b7, 0xf54a_7312_517f_386d, 0x4c8f_ba9e_7f58_9015, 0xe68b_c3c5_a269_98c0, 0x0930_ba16_c101_df98, 0xc67e_e020_da17_4324, 0x80c6_6591_68f0_f459, 0xea02_46bf_9e57_7c4c, 0xed87_3fa2_9233_94ab, 0xbb5b_c99e_b41d_a775, 0x8b41_3538_0770_274e, 0xa7dc_f5d6_062a_1e95, 0x1716_f25d_129b_7463], + [0x138b_3c12_ae9b_da3b, 0xf65a_353a_faa7_de71, 0x0831_1be0_0eab_42d6, 0xa069_e43b_58ce_d0b3, 0xd589_933a_edfb_2ceb, 0xfdbd_fa54_563a_03dd, 0xe63f_0f09_2c75_38d8, 0x3b77_e1b6_0b6f_f8b2, 0x8b2e_0092_f927_8112, 0x0e4e_351c_b6f0_f039, 0x4443_fa39_5d5a_0424, 0xa28c_b204_8a33_66e5, 0xf32f_48ce_523d_869f, 0x094b_d2a8_ff82_773e, 0x7718_41aa_0a35_3a59, 0x023a_4268_ab7c_32e3], + [0x557a_191c_03a9_ee53, 0xcee6_c01b_76be_d685, 0x62e3_3aa9_2c63_b5c4, 0x2d83_0be3_875f_feba, 0x59a7_c9d2_ba4e_854f, 0x49f1_8352_5a13_9bb6, 0x1762_cc0a_2801_b21b, 0x7384_3dd8_ff30_29f2, 0xba13_e503_3fc6_ef08, 0xe4b6_1360_0514_0cd1, 0x669b_7672_1692_b063, 0x6d3c_a85c_9752_e4f9, 0xd197_5ffe_b871_f430, 0xdcc8_eb71_8d25_5731, 0xaaa8_5adf_5bb6_00d9, 0x0012_9de5_700e_2617], +]; + +#[cfg(all(feature = "big-table", feature = "big-int"))] +pub const CUBIC_MODULI: [u16; 8] = [819, 817, 925, 961, 1021, 1009, 997, 991]; +#[rustfmt::skip] +#[cfg(all(feature = "big-table", feature = "big-int"))] +pub const CUBIC_RESIDUAL: [[u64; 16]; 8] = [ + [0x0000_0000_0800_0103, 0x2040_0008_0c00_0001, 0x4020_0002_0000_0000, 0x1000_0000_0100_0000, 0x0008_0000_8000_0010, 0x0600_0000_c080_0000, 0x0600_0000_0000_0000, 0x0000_0000_1030_0000, 0x0080_8000_0010_0001, 0x4020_0000_0800_0000, 0x2040_0000_0004_0000, 0x0008_0000_0301_0000, 0x0004_0800_0100_0000, 0, 0, 0 ], + [0x0000_2080_0800_0903, 0x2202_0840_4190_0803, 0x0080_1c10_0082_1020, 0x4080_1000_0300_0000, 0x0102_8220_2004_040c, 0x0800_0100_00c0_000c, 0x0040_6408_0000_4098, 0x0200_c000_0c00_0200, 0x0408_c080_8010_1105, 0x0400_0000_0300_0020, 0x0110_1021_0400_20e0, 0x0003_0040_2608_0841, 0x0001_0240_0040_0410, 0, 0, 0 ], + [0x8009_8870_ac80_4943, 0x26a1_80b2_0114_0e15, 0x850a_c804_d438_4640, 0x2b00_1310_e159_0092, 0x800d_4301_4402_280c, 0x250a_1490_09a8_70ac, 0x1856_0026_21c2_b201, 0x1900_1a86_0a88_0454, 0x024a_1429_2013_50e1, 0xa030_ac00_4d43_8564, 0xc232_0035_0c05_1008, 0xc804_d428_5240_26a1, 0x1340_6159_0098_870a, 0x4384_6400_6a1c_0a20, 0x0000_0000_10a4_804d, 0 ], + [0xb440_c08b_6881_8117, 0x6d10_3022_da20_6045, 0x5b44_0c08_b688_1811, 0x16d1_0302_2da2_0604, 0x45b4_40c0_8b68_8181, 0x116d_1030_22da_2060, 0x045b_440c_08b6_8818, 0x8116_d103_022d_a206, 0x6045_b440_c08b_6881, 0x1811_6d10_3022_da20, 0x0604_5b44_0c08_b688, 0x8181_16d1_0302_2da2, 0x2060_45b4_40c0_8b68, 0x8818_116d_1030_22da, 0xa206_045b_440c_08b6, 0x0000_0000_0000_0001], + [0x8153_0491_1d25_73df, 0x602b_1125_0832_c381, 0xa840_0704_788f_4809, 0xb408_2c4d_0921_0411, 0x9540_c075_104a_8243, 0xc4e0_1080_a2bd_8818, 0x226b_0403_8012_2321, 0xed12_0840_8cd2_1071, 0x2382_12cc_4084_122d, 0xe131_1200_7008_3591, 0x4604_6f51_4042_01c8, 0x7090_5482_2b80_c0aa, 0x6208_2124_2c8d_040b, 0xa404_bc47_8838_0085, 0x6070_d304_2922_3501, 0x1ef3_a92e_2248_32a0], + [0x7a04_9c88_0998_630b, 0x60b3_4380_0006_2731, 0x87da_2e01_2960_281a, 0x40cc_00a0_4918_b811, 0x1920_4804_1908_9410, 0x15e8_06b3_91a9_1404, 0x8032_92a2_0091_761c, 0x484b_0505_c1a2_b3cc, 0x3004_cf35_160e_8283, 0x5ea0_e1ba_2401_1525, 0x1260_80a2_5627_3580, 0xcc08_20a4_4260_8048, 0x6f86_2074_6248_1400, 0x3419_6050_1a52_01d1, 0x817a_3391_8000_070b, 0x0001_4318_6640_44e4], + [0x5045_2131_cb15_977f, 0x3182_b013_240b_0d09, 0x0e10_00c7_0851_00e1, 0x2789_4026_6502_0ba7, 0x80c0_1909_08a0_5403, 0x02d4_01a2_2088_fa95, 0x1c91_8024_8065_e415, 0x84bf_4869_1002_2614, 0x0062_4e0a_1910_0225, 0x600a_d02a_09e9_8049, 0x2600_c06a_57c4_4111, 0x00a4_7930_0a81_4424, 0xc002_1c39_7410_2999, 0x0350_6321_c022_8438, 0x2128_82a4_2c34_0932, 0x0000_001f_ba6a_34e3], + [0x300c_d468_2d12_430b, 0x704f_c6a2_80c6_e183, 0x0090_00c1_22c0_a750, 0x684c_67a8_07a3_2039, 0x4861_85ba_2168_0264, 0x0591_9495_0edb_a400, 0x4400_30c0_c94d_1004, 0x80a4_2501_8280_082e, 0x030c_0022_7410_0141, 0xa929_89a0_2008_b293, 0x5da1_8612_0025_db70, 0x15e6_3216_2640_1684, 0x8300_0900_9c04_c5e0, 0x4563_f20e_0ae5_0344, 0x162b_300c_c187_6301, 0x0000_0000_50c2_48b4], +]; diff --git a/vendor/num-prime/src/traits.rs b/vendor/num-prime/src/traits.rs new file mode 100644 index 0000000..878ea0d --- /dev/null +++ b/vendor/num-prime/src/traits.rs @@ -0,0 +1,455 @@ +use core::default::Default; +use std::ops::{BitAnd, BitOr, Mul}; + +use either::Either; +use num_integer::{Integer, Roots}; +use num_traits::Pow; + +/// This trait support unified bit testing for (unsigned) integers +pub trait BitTest { + /// Get the minimum required number of bits to represent this integer + fn bits(&self) -> usize; + + /// Get the i-th bit of the integer, with i specified by `position` + fn bit(&self, position: usize) -> bool; + + /// Get the number of trailing zeros in the integer + fn trailing_zeros(&self) -> usize; +} + +/// This enum describes the result of primality checks +#[derive(Debug, Clone, Copy, PartialEq)] +pub enum Primality { + /// The number passes deterministic primality check. + Yes, + /// The number is a composite and failed at least one specific primality check. + No, + /// The number passes several probabilistic primality check. + /// The associated float number carries the probability of the number being a prime + /// (conditioned on that it's already a probable prime) + Probable(f32), +} + +impl Primality { + /// Check whether the resule indicates that the number is + /// (very) probably a prime. Return false only on [`Primality::No`] + #[inline(always)] + #[must_use] + pub fn probably(self) -> bool { + !matches!(self, Primality::No) + } +} + +impl BitAnd for Primality { + type Output = Primality; + + /// Combine two primality results by ensuring both numbers are prime + fn bitand(self, rhs: Primality) -> Self::Output { + match self { + Primality::No => Primality::No, + Primality::Yes => rhs, + Primality::Probable(p) => match rhs { + Primality::No => Primality::No, + Primality::Yes => Primality::Probable(p), + Primality::Probable(p2) => { + let combined = p.mul(p2); + Primality::Probable(combined) + } + }, + } + } +} + +impl BitOr for Primality { + type Output = Primality; + + /// Combine two primality results by ensuring either numbers is prime + fn bitor(self, rhs: Primality) -> Self::Output { + match self { + Primality::No => rhs, + Primality::Yes => Primality::Yes, + Primality::Probable(p) => match rhs { + Primality::No => Primality::Probable(p), + Primality::Yes => Primality::Yes, + Primality::Probable(p2) => Primality::Probable(1. - (1. - p) * (1. - p2)), + }, + } + } +} + +/// Represents a configuration for a primality test +#[derive(Debug, Clone, Copy)] +#[non_exhaustive] +pub struct PrimalityTestConfig { + // TODO: add option to divides small primes in the table + // and this option should be enabled if the probabilistic test is used for strict config + /// Number of strong probable prime test, starting from base 2 + pub sprp_trials: usize, + + /// Number of strong probable prime test with random bases + pub sprp_random_trials: usize, + + /// Whether perform strong lucas probable prime test (with automatically selected parameters) + pub slprp_test: bool, + + /// Whether perform extra strong lucas probable prime test (with automatically selected parameters) + pub eslprp_test: bool, +} + +impl Default for PrimalityTestConfig { + /// Create a defalt primality testing configuration. This config will eliminate most + /// composites with little computation + fn default() -> Self { + Self { + sprp_trials: 2, // test base 2 and 3 + sprp_random_trials: 3, // choose other 3 random bases + slprp_test: false, + eslprp_test: false, + } + } +} + +impl PrimalityTestConfig { + /// Create a configuration with a very strong primality check. It's based on + /// the **strongest deterministic primality testing** and some SPRP tests with + /// random bases. + #[must_use] + pub fn strict() -> Self { + let mut config = Self::bpsw(); + config.sprp_random_trials = 1; + config + } + + /// Create a configuration for Baillie-PSW test (base 2 SPRP test + SLPRP test) + #[must_use] + pub fn bpsw() -> Self { + Self { + sprp_trials: 1, + sprp_random_trials: 0, + slprp_test: true, + eslprp_test: false, + } + } +} + +/// Represents a configuration for integer factorization +#[derive(Debug, Clone, Copy)] +#[non_exhaustive] +pub struct FactorizationConfig { + /// Config for testing if a factor is prime + pub primality_config: PrimalityTestConfig, + + /// Prime limit of trial division, you also need to reserve the primes in the buffer + /// if all primes under the limit are to be tested. `None` means using all available primes. + pub td_limit: Option, + + /// Number of trials with Pollard's rho method + pub rho_trials: usize, +} + +impl Default for FactorizationConfig { + /// Create a defalt primality testing configuration. This config will factorize + /// most integers within decent time + fn default() -> Self { + const THRESHOLD_DEFAULT_TD: u64 = 1 << 14; + Self { + primality_config: PrimalityTestConfig::default(), + td_limit: Some(THRESHOLD_DEFAULT_TD), + rho_trials: 4, + } + } +} + +impl FactorizationConfig { + /// Same as the default configuration but with strict primality check + #[must_use] + pub fn strict() -> Self { + Self { + primality_config: PrimalityTestConfig::strict(), + ..Self::default() + } + } +} + +// FIXME: backport to num_integer (see https://github.com/rust-num/num-traits/issues/233) +/// Extension on [`num_integer::Roots`] to support perfect power check on integers +pub trait ExactRoots: Roots + Pow + Clone { + fn nth_root_exact(&self, n: u32) -> Option { + let r = self.nth_root(n); + if &r.clone().pow(n) == self { + Some(r) + } else { + None + } + } + fn sqrt_exact(&self) -> Option { + self.nth_root_exact(2) + } + fn cbrt_exact(&self) -> Option { + self.nth_root_exact(3) + } + fn is_nth_power(&self, n: u32) -> bool { + self.nth_root_exact(n).is_some() + } + fn is_square(&self) -> bool { + self.sqrt_exact().is_some() + } + fn is_cubic(&self) -> bool { + self.cbrt_exact().is_some() + } +} + +// TODO: implement is_perfect_power, this could be used during factorization +// to filter out perfect powers when factorize large integers +// REF: PARI/GP `Z_ispowerall`, `is_357_power` +// FLINT `n_is_perfect_power235`, `fmpz_is_perfect_power` +// GMP `mpz_perfect_power_p` + +/// This trait represents a general data structure that stores primes. +/// +/// It's recommended to store at least a bunch of small primes in the buffer +/// to make some of the algorithms more efficient. +pub trait PrimeBuffer<'a> { + type PrimeIter: Iterator; + + /// Directly return an iterator of existing primes + fn iter(&'a self) -> Self::PrimeIter; + + /// Generate primes until the largest prime in the buffer is equal or larger than limit + fn reserve(&mut self, limit: u64); + + /// Get the largest primes in the list + fn bound(&self) -> u64; + + /// Test if the number is in the buffer. If a number is not in the buffer, + /// then it's either a composite or large than [`PrimeBuffer::bound()`] + fn contains(&self, num: u64) -> bool; + + /// clear the prime buffer to save memory + fn clear(&mut self); +} + +/// This trait implements various primality testing algorithms +/// +/// Reference: +/// - +pub trait PrimalityUtils: Integer + Clone { + /// Test if the integer is a (Fermat) probable prime + fn is_prp(&self, base: Self) -> bool; + + /// Test if the integer is a strong probable prime (based on Miller-Rabin test). + fn is_sprp(&self, base: Self) -> bool; + + /// Do a Miller-Rabin test. The return value is a integer if it finds a factor of + /// the integer, otherwise it reports the test result. + fn test_sprp(&self, base: Self) -> Either; + + /// Test if the integer is a Lucas probable prime + /// If either of p, q is not specified, then we will use Selfridge's Method A to choose p, q + fn is_lprp(&self, p: Option, q: Option) -> bool; + + /// Test if the integer is a strong Lucas probable prime + /// If either of p, q is not specified, then we will use Selfridge's Method A to choose p, q + fn is_slprp(&self, p: Option, q: Option) -> bool; + + /// Test if the integer is an extra strong Lucas probable prime + /// If p is not specified, then first p starting from 3 such that Jacobi symbol is -1 will be chosen, which is sometimes refered as "Method C" + fn is_eslprp(&self, p: Option) -> bool; + + // TODO: implement ECPP test + // https://en.wikipedia.org/wiki/Elliptic_curve_primality + + // TODO: implement is_vprp (Lucas-V probable prime test) + // https://arxiv.org/pdf/2006.14425.pdf +} + +/// Supports random generation of primes +pub trait RandPrime { + /// Generate a random prime within the given bit size limit + /// + /// # Panics + /// if the `bit_size` is 0 or it's larger than the bit width of the integer + fn gen_prime(&mut self, bit_size: usize, config: Option) -> T; + + /// Generate a random prime with **exact** the given bit size + /// + /// # Panics + /// if the `bit_size` is 0 or it's larger than the bit width of the integer + fn gen_prime_exact(&mut self, bit_size: usize, config: Option) -> T; + + /// Generate a random (Sophie German) safe prime within the given bit size limit. The generated prime + /// is guaranteed to pass the [`is_safe_prime`][crate::nt_funcs::is_safe_prime] test + /// + /// # Panics + /// if the `bit_size` is 0 or it's larger than the bit width of the integer + fn gen_safe_prime(&mut self, bit_size: usize) -> T; + + /// Generate a random (Sophie German) safe prime with the **exact** given bit size. The generated prime + /// is guaranteed to pass the [`is_safe_prime`][crate::nt_funcs::is_safe_prime] test + /// + /// # Panics + /// if the `bit_size` is 0 or it's larger than the bit width of the integer + fn gen_safe_prime_exact(&mut self, bit_size: usize) -> T; +} + +#[cfg(test)] +mod tests { + use super::*; + + // --- Primality::probably() --- + #[test] + fn primality_probably() { + assert!(Primality::Yes.probably()); + assert!(!Primality::No.probably()); + assert!(Primality::Probable(0.9).probably()); + } + + // --- Primality BitAnd: all 9 combinations --- + #[test] + fn primality_bitand_no_lhs() { + assert_eq!(Primality::No & Primality::No, Primality::No); + assert_eq!(Primality::No & Primality::Yes, Primality::No); + assert_eq!(Primality::No & Primality::Probable(0.9), Primality::No); + } + + #[test] + fn primality_bitand_yes_lhs() { + assert_eq!(Primality::Yes & Primality::No, Primality::No); + assert_eq!(Primality::Yes & Primality::Yes, Primality::Yes); + assert_eq!( + Primality::Yes & Primality::Probable(0.8), + Primality::Probable(0.8) + ); + } + + #[test] + fn primality_bitand_probable_lhs() { + assert_eq!(Primality::Probable(0.9) & Primality::No, Primality::No); + assert_eq!( + Primality::Probable(0.9) & Primality::Yes, + Primality::Probable(0.9) + ); + // Probable & Probable => combined probability + let result = Primality::Probable(0.8) & Primality::Probable(0.9); + match result { + Primality::Probable(p) => assert!((p - 0.72).abs() < 1e-6), + _ => panic!("expected Probable"), + } + } + + // --- Primality BitOr: all 9 combinations --- + #[test] + fn primality_bitor_no_lhs() { + assert_eq!(Primality::No | Primality::No, Primality::No); + assert_eq!(Primality::No | Primality::Yes, Primality::Yes); + assert_eq!( + Primality::No | Primality::Probable(0.8), + Primality::Probable(0.8) + ); + } + + #[test] + fn primality_bitor_yes_lhs() { + assert_eq!(Primality::Yes | Primality::No, Primality::Yes); + assert_eq!(Primality::Yes | Primality::Yes, Primality::Yes); + assert_eq!(Primality::Yes | Primality::Probable(0.8), Primality::Yes); + } + + #[test] + fn primality_bitor_probable_lhs() { + assert_eq!( + Primality::Probable(0.9) | Primality::No, + Primality::Probable(0.9) + ); + assert_eq!(Primality::Probable(0.9) | Primality::Yes, Primality::Yes); + // Probable | Probable => 1 - (1-p1)*(1-p2) + let result = Primality::Probable(0.8) | Primality::Probable(0.9); + match result { + Primality::Probable(p) => assert!((p - 0.98).abs() < 1e-6), + _ => panic!("expected Probable"), + } + } + + // --- PrimalityTestConfig constructors --- + #[test] + fn primality_test_config_default() { + let c = PrimalityTestConfig::default(); + assert_eq!(c.sprp_trials, 2); + assert_eq!(c.sprp_random_trials, 3); + assert!(!c.slprp_test); + assert!(!c.eslprp_test); + } + + #[test] + fn primality_test_config_bpsw() { + let c = PrimalityTestConfig::bpsw(); + assert_eq!(c.sprp_trials, 1); + assert_eq!(c.sprp_random_trials, 0); + assert!(c.slprp_test); + assert!(!c.eslprp_test); + } + + #[test] + fn primality_test_config_strict() { + let c = PrimalityTestConfig::strict(); + assert_eq!(c.sprp_trials, 1); + assert_eq!(c.sprp_random_trials, 1); + assert!(c.slprp_test); + assert!(!c.eslprp_test); + } + + // --- FactorizationConfig constructors --- + #[test] + fn factorization_config_default() { + let c = FactorizationConfig::default(); + assert_eq!(c.td_limit, Some(1 << 14)); + assert_eq!(c.rho_trials, 4); + } + + #[test] + fn factorization_config_strict() { + let c = FactorizationConfig::strict(); + assert_eq!(c.td_limit, Some(1 << 14)); + assert_eq!(c.rho_trials, 4); + // uses strict primality config + assert_eq!(c.primality_config.sprp_trials, 1); + assert_eq!(c.primality_config.sprp_random_trials, 1); + assert!(c.primality_config.slprp_test); + } + + // --- ExactRoots helper methods --- + #[test] + fn exact_roots_is_square() { + assert!(16u64.is_square()); + assert!(!15u64.is_square()); + assert!(1u64.is_square()); + assert!(100u64.is_square()); + assert!(!99u64.is_square()); + } + + #[test] + fn exact_roots_is_cubic() { + assert!(27u64.is_cubic()); + assert!(!26u64.is_cubic()); + assert!(1u64.is_cubic()); + assert!(64u64.is_cubic()); + } + + #[test] + fn exact_roots_is_nth_power() { + assert!(256u64.is_nth_power(4)); + assert!(!255u64.is_nth_power(4)); + } + + #[test] + fn exact_roots_sqrt_exact() { + assert_eq!(49u64.sqrt_exact(), Some(7)); + assert_eq!(50u64.sqrt_exact(), None); + } + + #[test] + fn exact_roots_cbrt_exact() { + assert_eq!(125u64.cbrt_exact(), Some(5)); + assert_eq!(126u64.cbrt_exact(), None); + } +} diff --git a/vendor/num-prime/src/util.rs b/vendor/num-prime/src/util.rs new file mode 100644 index 0000000..43c4b57 --- /dev/null +++ b/vendor/num-prime/src/util.rs @@ -0,0 +1,9 @@ +pub const fn div_ceil_u64(lhs: u64, rhs: u64) -> u64 { + let d = lhs / rhs; + let r = lhs % rhs; + if r > 0 { + d + 1 + } else { + d + } +}