Initial commit
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..53eaa21
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,2 @@
+/target
+**/*.rs.bk
diff --git a/.gitmodules b/.gitmodules
new file mode 100644
index 0000000..ad2597c
--- /dev/null
+++ b/.gitmodules
@@ -0,0 +1,3 @@
+[submodule "boringssl/boringssl"]
+ path = boringssl/boringssl
+ url = https://boringssl.googlesource.com/boringssl
diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 0000000..b572595
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,13 @@
+<!-- Copyright 2018 Google LLC
+
+Use of this source code is governed by an MIT-style
+license that can be found in the LICENSE file or at
+https://opensource.org/licenses/MIT. -->
+
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/).
+
+## [Unreleased]
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
new file mode 100644
index 0000000..e06004a
--- /dev/null
+++ b/CONTRIBUTING.md
@@ -0,0 +1,193 @@
+<!-- Copyright 2018 Google LLC
+
+Use of this source code is governed by an MIT-style
+license that can be found in the LICENSE file or at
+https://opensource.org/licenses/MIT. -->
+
+# Contributing
+
+## Code Guidelines
+
+### Unsafe
+
+`unsafe` is not allowed, except for in the `boringssl` module. We
+`#[forbid(unsafe)]` in all other modules, so code that uses `unsafe` outside of
+that module should fail to compile. For details on how to use `unsafe` in the
+`boringssl` module, see the doc comment on that module.
+
+### `#[must_use]`
+
+The `#[must_use]` directive causes the compiler to emit a warning if code calls
+a function but does not use its return value. It is a very useful lint against
+failing to properly act on the result of cryptographic operations. A
+`#[must_use]` directive should go on:
+- All functions/methods (including in trait definitions) which return a value
+ and are visible outside of the crate
+- In the `boringssl` module:
+ - All functions/methods (including in trait definitions) which return a value
+ and are visible outside of the `boringssl` module or are exported from the
+ `raw` or `wrapper` modules to the top-level `boringssl` module
+
+`#[must_use]` may also be used on types, but should be evaluated on a
+case-by-case basis. A few things to keep in mind:
+- All functions defined in `mundane` which return values have `#[must_use]` on
+ them, so the case of a type returned by a function defined in `mundane` is
+ already covered.
+- Unlike on functions, `#[must_use]` on types affects code other than the
+ immediate caller since code outside of this crate may return types which are
+ defined in this crate.
+
+Thus, `#[must_use]` should only be used on a type when it's desired for
+functions defined outside of this crate which return the type to have
+`#[must_use]` behavior.
+
+As a general rule of thumb, this should be restricted to types which could be
+used to make security decisions. For example, digests and signatures should have
+`#[must_use]`, while keys should not have it.
+
+*TODO(joshlf): Re-evaluate this policy? Maybe we want to put `#[must_use]` on
+more types?*
+
+### Insecure
+
+Some clients require access to insecure operations in order to interoperate with
+legacy applications. While we provide these operations, we do so with a few
+caveats:
+- We only provide the bare minimum required. For example, while we provide
+ HMAC-SHA1, we do not provide SHA-1 on its own, as it is not needed.
+- We attempt to make it as difficult as possible for somebody to use an insecure
+ operation unintentionally, as detailed in the next section.
+
+#### Adding Insecure Operations
+
+We use a number of mechanisms to make it less likely for somebody to use an
+insecure operation unintentionally or without understanding the implications.
+They are:
+- Use of Rust's `#[deprecated]` attribute so that code which uses insecure
+ operations will produce a compiler warning
+- Naming of insecure types, functions, and methods with an "insecure" prefix so
+ that their use will stand out in code, and their insecurity will stand out
+ when reading their documentation
+- Documentation comments that stress the operation's insecurity
+- Placing all insecure operations in their own `insecure` module so that users
+ are unlikely to accidentally come across an insecure operation while browsing
+ other documentation
+- Placing the `insecure` module behind a feature flag which is disabled by
+ default
+
+The whole is also more than the sum of the parts. Taken together, these
+mechanisms serve to give an appropriate air of gravitas to insecure operations.
+Users should feel uneasy - like they're wading into dangerous and subtle
+territory (because they are!). They should be made to feel the gravity of the
+situation, and to appreciate the importance of carefully considering whether
+using an insecure operation is appropriate.
+
+##### Deprecation
+
+Rust provides the `#[deprecated]`
+[attribute](https://doc.rust-lang.org/reference/attributes.html) which can be
+placed on items including modules, types, functions, methods, and traits. If a
+deprecated item is imported or used, it will cause a compiler warning (two,
+actually - one for the import, and one for the use in code).
+
+In `mundane`, all insecure operations must be marked with a `#[deprecated]`
+attribute with an appropriate message. This includes all items that a user could
+ever interact with - types, functions, methods, etc. If it has a `pub` in front
+of it, it needs a deprecation attribute. For example:
+
+```rust
+#[deprecated(note = "Foo is considered insecure")]
+pub struct InsecureFooResult;
+
+impl InsecureFooResult {
+ #[deprecated(note = "Foo is considered insecure")]
+ pub fn insecure_frobnicate(&self) { ... }
+}
+
+#[deprecated(note = "Foo is considered insecure")]
+pub fn insecure_foo() -> InsecureFooResult { ... }
+```
+
+##### Naming
+
+Every user-facing Rust item associated with an insecure operation carries an
+"insecure" prefix on its name. For types and traits, this is of the form
+`Insecure`, while for functions, methods, and modules, it's of the form
+`insecure_`. See the example from the previous section for a demonstration of
+this naming.
+
+The justification for this is twofold. First, it makes it so that, while reading
+documentation, it's unlikely for even a casual reader to miss that what they're
+reading about is a special case that should be carefully considered. Second, it
+makes it very obvious when reading or reviewing code that makes use of insecure
+operations.
+
+##### Documentation
+
+Every documentation comment on an insecure operation should have the following
+structure:
+
+```rust
+/// INSECURE: <summary of operation>
+///
+/// # Security
+///
+/// <operation> is considered insecure, and should only be used for compatibility
+/// with legacy applications.
+///
+/// <further documentation if necessary>
+```
+
+As with naming, this serves to lessen the likelihood that a user will use an
+insecure operation without realizing what they're doing.
+
+##### Module Isolation
+
+All insecure operations are exposed through a top-level `insecure` module, which
+is itself marked with a deprecation attribute, and carries appropriate
+module-level documentation.
+
+Unfortunately, due to Rust's visibility rules, making this work involves a bit
+of a dance. For reasons of practicality, insecure operations are defined
+alongside their secure counterparts. For example, the `InsecureHmacSha1` type is
+defined in the `hmac` module, and the `InsecureSha1Digest` type is defined in
+the `hash` module. A programmer's first inclination might be to mark these as
+`pub(crate)` and attempt to re-export them from the `insecure` module.
+Unfortunately, Rust forbids this.
+
+Instead, we take the somewhat circuitous approach of putting an insecure
+operation inside of its own `pub(crate)` module (e.g.,
+`hmac::insecure_hmac_sha1`). Inside of this module, the insecure operation can be
+`pub` rather than `pub(crate)`. This, in turn, allows the `insecure` module to
+re-export the item without running afoul of the compiler. It's an awkward dance,
+but it makes it so that insecure operations can only be accessed through the
+`insecure` module, which is a big win.
+
+##### Feature Gating
+
+By default, the `insecure` module is not present. The user must explicitly
+enable the `insecure` feature in order to enable the module.
+
+## Contributor License Agreement
+
+Contributions to this project must be accompanied by a Contributor License
+Agreement. You (or your employer) retain the copyright to your contribution;
+this simply gives us permission to use and redistribute your contributions as
+part of the project. Head over to <https://cla.developers.google.com/> to see
+your current agreements on file or to sign a new one.
+
+You generally only need to submit a CLA once, so if you've already submitted one
+(even if it was for a different project), you probably don't need to do it
+again.
+
+## Code reviews
+
+All submissions, including submissions by project members, require review. We
+use GitHub pull requests for this purpose. Consult
+[GitHub Help](https://help.github.com/articles/about-pull-requests/) for more
+information on using pull requests.
+
+## Community Guidelines
+
+This project follows [Google's Open Source Community
+Guidelines](https://opensource.google.com/conduct/).
\ No newline at end of file
diff --git a/Cargo.toml b/Cargo.toml
new file mode 100644
index 0000000..1dd61ac
--- /dev/null
+++ b/Cargo.toml
@@ -0,0 +1,23 @@
+# Copyright 2018 Google LLC
+#
+# Use of this source code is governed by an MIT-style
+# license that can be found in the LICENSE file or at
+# https://opensource.org/licenses/MIT.
+
+[package]
+name = "mundane"
+# remember to update html_root_url
+# TODO(joshlf): use version-sync crate to test this in CI
+version = "0.2.0"
+authors = ["Joshua Liebow-Feeser <joshlf@google.com>"]
+description = "Cryptography which is easy to use and hard to misuse"
+readme = "README.md"
+license-file = "LICENSE"
+keywords = ["boringssl"]
+categories = ["cryptography"]
+repository = "https://github.com/google/mundane"
+
+[features]
+insecure = []
+kdf = []
+rand-bytes = []
diff --git a/DESIGN.md b/DESIGN.md
new file mode 100644
index 0000000..f9ae5a5
--- /dev/null
+++ b/DESIGN.md
@@ -0,0 +1,197 @@
+<!-- Copyright 2018 Google LLC
+
+Use of this source code is governed by an MIT-style
+license that can be found in the LICENSE file or at
+https://opensource.org/licenses/MIT. -->
+
+# Design of the `mundane` crate
+
+`mundane` has the following design goals, in this order:
+- To be difficult to misuse
+- To be ergonomic
+- To be performant
+
+This document describes both the overall philosophy, and also specific design
+patterns used to achieve these goals
+
+# Philosophy
+
+Cryptography is famously subtle and easy to get wrong. And when cryptography is
+done wrong, the results can be catastrophic.
+
+Experience has shown that most programmers, not being familiar with the
+subtleties of cryptography, will unknowingly misuse cryptographic libraries if
+they are allowed. This is one example of a broader trend - that it's difficult
+to get something right if getting it wrong doesn't affect whether your program
+runs. It's the same reason that error handling code is so often buggy in
+otherwise well-written programs. Misuse of cryptography, like buggy error
+handling, is unlikely to show up in tests, and unlikely to affect the
+correctness of a program under normal conditions. But unlike error handling,
+most programmers aren't familiar with the requirements of using cryptography
+securely, and getting it wrong can be absolutely fatal.
+
+Given this realization, `mundane` takes the approach of giving the programmer
+the fewest degrees of freedom possible. Doing the right thing should be easy and
+feel natural. Doing the wrong thing should feel difficult and ideally be
+entirely impossible. This philosophy motivates the design patterns which are
+explored in the next section.
+
+# Design Patterns
+
+## Do work for the user
+
+Some cryptographic operations have setup phases, require generating random
+values, computing key schedules, etc. While many cryptographic APIs split these
+into multiple steps that must be performed by the user in the right order,
+prefer APIs which perform all setup steps on behalf of the user. This reduces
+the opportunities for the user to make a mistake.
+
+For example, the scrypt password-based key derivation function takes a salt.
+When generating a key from a new password, the salt should always be randomly
+generated anew. Instead of taking the salt as an argument, as many cryptographic
+APIs do, we generate the salt as part of the generation function -
+`scrypt_generate` - so that the user is not given the opportunity to improperly
+generate it.
+
+As another example, while scrypt can be used as a general-purpose key derivation
+function, we expose it specifically for password verification. Thus, instead of
+having the API expose the ability to take a password and a salt and generate a
+hash, leaving it up to the user to verify that the calculated hash matches the
+expected one, our API takes a password, a salt, and a hash, computes the new
+hash, checks it against the expected one, and returns a boolean. Not only does
+this ensure that the comparison is not accidentally skipped, it also allows us
+to ensure that the comparison is performed using a constant-time comparison
+function, which is a subtle detail that is often overlooked by users.
+
+## Types
+
+All cryptographic operations have data associated with them. A hash function
+takes a byte sequence and outputs a digest. A signature functions takes a
+private key and a digest, and outputs a signature.
+
+These types of data usually have strict definitions of what operations are valid
+or secure to perform on them. The Rust type system provides a powerful mechanism
+to enforce that users cannot use these cryptographic objects other than as
+intended.
+
+### Opaque types
+
+The easiest way to restrict the set of allowed operations on a type is to make
+it opaque - that is, to create a struct with private fields, and provide only
+the minimum set of methods or trait implementations needed. For example, instead
+of representing a SHA-256 digest as a `[u8; 32]`, we represent it as an opaque
+struct, `Sha256Digest`, which has a private `[u8; 32]` field.
+
+Given such an opaque type, we can be judicious about methods or trait
+implementations to provide. For example, a SHA-256 digest should be comparable
+for equality with other SHA-256 digests, and so `Sha256Digest` implements `Eq`
+for itself. However, comparing with digests from other hash functions is not a
+cryptographically meaningful operation, so it doesn't implement `Eq` for other
+types of digests. Similarly, the `EcdsaSignature` type provides only a
+constructor and a getter, as no other operations (including comparison between
+signatures) are meaningful.
+
+It will usually be necessary to allow the user to access a non-opaque
+representation (such as a byte array for hash digests). However, it is
+sufficient to only provide constructors and getters. For example, the `Digest`
+trait provides a `from_bytes(bytes: [u8; Self::DIGEST_LEN]) -> Self`
+constructor, and a `bytes(&self) -> [u8; Self::DIGEST_LEN]` getter, but does not
+provide, for example, `bytes_mut(&mut self) -> &mut [u8; Self::DIGEST_LEN]`.
+
+### Use distinct types even if they have the same operations
+
+Sometimes, distinct cryptographic objects will have the same representations and
+operations allowed on them. For example, both RIPEMD-160 and SHA-1 produce
+20-byte digests. Even if this happens, distinct Rust types should still be used.
+Since it is never valid to compare a RIPEMD-160 digest to a SHA-1 digest,
+representing them with the same Rust type would allow operations that are not
+valid. Representing them with distinct Rust types ensures that they are not
+spuriously used together in an invalid or insecure way.
+
+### Use the most restrictive type
+
+At some point, it will be necessary to accept or provide a non-opaque
+representation so that input can be gathered from the outside world or output to
+it. When this happens, use the most restrictive type in order to avoid having
+to perform validation at runtime.
+
+For example, hash digests have a fixed length. Thus, their constructors accept
+(and their getters produce) fixed-length byte arrays. If, instead,
+variable-length byte slices were used, it would be necessary a) to document the
+length requirement, b) to validate the length during construction, and panic if
+it failed, and c) to promise to the user to always produce slices of a
+particular length. By using fixed-length arrays, we allow the type system to
+guarantee that input will always be valid - so we don't need to perform any
+validation - and to guarantee that the output will always conform to what is
+documented - so the user doesn't need to simply trust our documentation.
+
+### Put as much as possible in the type system
+
+If a distinction exists between two cryptographic objects, always try to encode
+that distinction in the type system if possible (of course, don't go over board;
+ergonomics and other considerations are important too).
+
+For example, most cryptography libraries provide a single elliptic curve private
+key type. However, elliptic curve keys have a curve parameter, and two keys over
+different curves are not interchangable - they might as well be completely
+different cryptosystems. Thus, we provide a `PCurve` trait which is implemented
+by various curve types, and our private key type, `EcKey` is parametrized on
+such a type - `EcKey<C: PCurve>`.
+
+## Errors
+
+Error return values from cryptographic functions are an infamous source of
+vulnerabilities. As with any system, the error handling logic of a program is
+often the last consideration of a programmer, and is rarely exercised in tests.
+More so than most systems, however, failure to properly handle errors from
+cryptographic functions can easily lead to catastrophic vulnerabilities.
+
+In order to avoid an opportunity for error values to be misused, we follow
+the following design guidelines:
+- Always use the Rust `Result` type to report errors. This may be a no-brainer,
+ but it means that, if the user wants to extract the return value from a
+ function, they *must* handle errors (at the very least, by calling `unwrap` or
+ `expect`, and thus panicking on failure). This contrasts with a language like
+ C, in which failing to check status return codes is easy and a common source
+ of bugs.
+- Collapse the distinction between "verification failed" and "verification
+ encountered an error." When verifying cryptographic objects like comparing
+ digests, verifying signatures, etc, there can sometimes be errors that are not
+ the same as a verification failure. For example, a verification routine might
+ fail to allocate memory, or it might fail to parse an encoded signature.
+ Instead of having a verification routine provide three possible return values
+ (verification succeeded, verification failed, or error encountered) we
+ collapse the last two into a single one - verification failed. That way, the
+ user is never given the opportunity to try to make subtle error-handling
+ decisions that might lead to them mistakenly accepting an invalid signature as
+ valid.
+- If an error requires particularly subtle error-handling, prefer panicking or
+ aborting the process. When cryptographic operations fail in a way that would
+ require reporting an error to the user (in other words, there's no valid
+ non-error interpretation like in the case of signature verification), and
+ handling that failure is particularly error-prone, it may be justified to make
+ the function's API infallible, and instead panic or abort the process on
+ error. BoringSSL famously does this when failing to read randomness (e.g.,
+ from `/dev/urandom`), as this has historically been a source of
+ vulnerabilities.
+
+## Attributes
+
+Rust has two attributes which will cause compiler warnings in user code
+if elements of the `mundane` API are misused.
+- The `#[must_use]` attribute on a function causes a compiler warning if a user
+ calls the function and discards the result. We put this attribute on all
+ functions which return values, as it is always suspicious to call a
+ side-effect-free function and ignore its result (most of our functions which
+ return values are side-effect free). This is especially useful in cases like
+ signature or hash verification, where failure to check the return value from a
+ function could lead to a catastrophic vulnerability (the iOS [`goto fail` TLS
+ verification
+ bug](https://nakedsecurity.sophos.com/2014/02/24/anatomy-of-a-goto-fail-apples-ssl-bug-explained-plus-an-unofficial-patch/)
+ is a famous example of this).
+
+ Similarly, `#[must_use]` on a type will cause a compiler warning if a user
+ ever calls a function which returns that type and discards the result.
+- The `#[deprecated]` attribute causes a warning whenever an item is imported or
+ used anywhere in code. We make liberal use of this attribute for our insecure,
+ legacy-only operations like SHA-1. See `CONTRIBUTING.md` for more details.
\ No newline at end of file
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..e5ccb02
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,18 @@
+Copyright 2018 Google LLC. All rights reserved.
+
+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/README.md b/README.md
new file mode 100644
index 0000000..652edb3
--- /dev/null
+++ b/README.md
@@ -0,0 +1,48 @@
+<!-- Copyright 2018 Google LLC
+
+Use of this source code is governed by an MIT-style
+license that can be found in the LICENSE file or at
+https://opensource.org/licenses/MIT. -->
+
+# mundane
+
+`mundane` is a Rust cryptography library backed by BoringSSL that is difficult
+to misuse, ergonomic, and performant (in that order).
+
+## Dependencies
+
+`mundane` vendors a copy of the BoringSSL source, so BoringSSL does not need to
+be installed locally in order to build. However, the BoringSSL build system has
+the following dependencies:
+- [CMake](https://cmake.org/download/) 2.8.11 or later
+- Perl 5.6.1 or later. See [BoringSSL's build
+ instructions](https://boringssl.googlesource.com/boringssl/+/master/BUILDING.md)
+ for what to do if CMake fails to find Perl on your system.
+- Either Make or [Ninja](https://ninja-build.org/). Ninja is preferable, as it
+ makes compilation significantly faster; if both are present, Ninja will be
+ used. On Windows, Ninja is required.
+- A C compiler
+- Go
+- To build the x86 and x86_64 assembly, your assembler must support AVX2
+ instructions and `MOVBE`. If using GNU binutils, you must have 2.22 or later.
+
+In order to avoid errors at link time due to conflicting symbols, we build
+BoringSSL with a custom prefix for all of its symbols which is based on the name
+and version of this crate. That way, even if multiple different versions of
+`mundane` are present in the same dependency graph, none of the symbols from one
+version's BoringSSL will conflict with the symbols from another version's
+BoringSSL.
+
+## Supported platforms
+
+`mundane` supports being built on and for Linux and Mac. Windows support is
+under development. Cross-compilation is not supported.
+
+## License
+
+Everything outside of the `boringssl/boringssl` directory is licensed under an
+MIT license which can be found in the `LICENSE` file. Everything in the
+`boringssl/boringssl` directory is licensed with a license that can be found in
+the `boringssl/boringssl/LICENSE` file.
+
+Disclaimer: mundane is not an officially supported Google product.
diff --git a/boringssl/README.md b/boringssl/README.md
new file mode 100644
index 0000000..d462c91
--- /dev/null
+++ b/boringssl/README.md
@@ -0,0 +1,96 @@
+<!-- Copyright 2018 Google LLC
+
+Use of this source code is governed by an MIT-style
+license that can be found in the LICENSE file or at
+https://opensource.org/licenses/MIT. -->
+
+# boringssl
+
+This directory contains source code and Rust bindings for Google's
+[BoringSSL](https://boringssl.googlesource.com/boringssl/) library.
+
+## Versions
+
+BoringSSL is vendored here, so each version of `mundane` will depend on a
+particular version of BoringSSL. Each new release will usually vendor the latest
+version of BoringSSL in order to pick up bug fixes and improvements.
+
+## Bindings
+
+Rust bindings live in `boringssl.rs`. This file is included from the main
+`mundane` source code using a `#[path]` attribute.
+
+These bindings are auto-generated using the `bindgen.sh` script, although some
+manual intervention is required. In particular, after running `bindgen.sh`, each
+public function must be annotated with a `#[link_name]` attribute (the reason
+for these attributes is explained in the following section). For example, given
+the following bindgen output:
+
+```rust
+extern "C" {
+ pub fn CBS_init(cbs: *mut CBS, data: *const u8, len: usize);
+}
+```
+
+We add a `#[link_name]` attribute as follows, where X.Y.Z is the current crate
+version.
+
+```rust
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_X_Y_Z_CBS_init"]
+ pub fn CBS_init(cbs: *mut CBS, data: *const u8, len: usize);
+}
+```
+
+## Symbol Prefixing
+
+Normally, the C build system does not allow multiple copies of the same codebase
+to be linked together since the namespace for C symbols is global at link time.
+In order to avoid this problem, we compile BoringSSL with a custom symbol prefix
+specific to the crate version. This document describes the details of how this
+works.
+
+### Prefixing
+
+Each BoringSSL symbol is given a prefix of `__RUST_MUNDANE_X_Y_Z_`, where the
+current crate version number is X.Y.Z. This way, if two different versions of
+the crate are present during a build, no C symbol will be defined under the same
+name in both builds of BoringSSL.
+
+### Two-phase build
+
+BoringSSL's build system has built-in support for symbol prefixing. However, it
+requires that the caller provide a list of symbols which need to be prefixed.
+Since the set of symbols present is highly platform-dependent, a static list
+would be very brittle and error-prone. Instead, we discover the symbols
+dynamically at build time by doing a two-phase build.
+
+In the first phase, we build BoringSSL as normal, with no symbol prefixing.
+Then, using a Go program provided by BoringSSL, we scrape the list of symbols
+from the build artifacts. Using this list, we run the build again - the second
+phase - this time using BoringSSL's symbol prefixing feature. We use the
+artifacts from the second build when performing the final Rust build.
+
+### Library names
+
+We instruct Rust to use the appropriate build artifacts using the linker path.
+The linker path is used in a manner similar to the binary `$PATH` in Unix
+systems. When a library is requested, the linker searches for a build artifact
+of the appropriate name, stopping its search once it has found the appropriate
+library. For example, given the argument `-l foo`, the linker would search for a
+file called `libfoo.a`.
+
+In order to ensure that the linker is able to find all copies of the BoringSSL
+build artifacts, we give them unique names. If we didn't, only the first
+artifact found in the filesystem would be used. Currently, we only link against
+the `crypto` library, which, in the normal build system, is stored in
+`libcrypto.a`. In order to make sure that all versions of this library are found
+by the linker - one per version of the crate - we rename them just as we rename
+symbols. For crate version x.y.z, we rename `libcrypto.a` to
+`libcrypto_x_y_z.a`, and instruct the linker to look for the `crypto_x_y_z`
+library.
+
+### Testing
+
+In order to test that symbol prefixing is working properly, use the
+`test_symbol_conflicts.sh` script in this directory.
\ No newline at end of file
diff --git a/boringssl/bindgen.h b/boringssl/bindgen.h
new file mode 100644
index 0000000..8297e68
--- /dev/null
+++ b/boringssl/bindgen.h
@@ -0,0 +1,17 @@
+// Copyright 2018 Google LLC
+//
+// Use of this source code is governed by an MIT-style
+// license that can be found in the LICENSE file or at
+// https://opensource.org/licenses/MIT.
+
+#include <openssl/bytestring.h>
+#include <openssl/curve25519.h>
+#include <openssl/ec.h>
+#include <openssl/ec_key.h>
+#include <openssl/ecdsa.h>
+#include <openssl/err.h>
+#include <openssl/evp.h>
+#include <openssl/hmac.h>
+#include <openssl/mem.h>
+#include <openssl/rand.h>
+#include <openssl/sha.h>
diff --git a/boringssl/bindgen.sh b/boringssl/bindgen.sh
new file mode 100755
index 0000000..c7ef530
--- /dev/null
+++ b/boringssl/bindgen.sh
@@ -0,0 +1,145 @@
+#!/bin/bash
+
+# Copyright 2018 Google LLC
+#
+# Use of this source code is governed by an MIT-style
+# license that can be found in the LICENSE file or at
+# https://opensource.org/licenses/MIT.
+
+set -e
+
+# cd to the directory this script lives in
+readonly SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+cd "$SCRIPT_DIR"
+
+if [ $# -ne 3 ]; then
+ echo "Usage: $0 <major> <minor> <patch>" >&2
+ exit 1
+fi
+
+MAJOR="$1"
+MINOR="$2"
+PATCH="$3"
+
+# TODO(joshlf):
+# - Use the --use-core flag once std isn't required (see
+# https://github.com/rust-lang-nursery/rust-bindgen/issues/1015)
+
+# Only include the symbols we want. It's important that we take the minimum
+# dependency on BoringSSL so that we provide the minimum burden for them. The
+# more symbols we depend on, the more likely it is that a change that they want
+# to make will affect us, which they will care about, making them either expend
+# effort in a graceful transition or decide to abandon the change. Thus, instead
+# of whitelisting broad classes of symbols, we explicitly whitelist the exact
+# list of symbols that mundane depends on.
+WHITELIST="(CBB|\
+CBB_cleanup|\
+CBB_data|\
+CBB_init|\
+CBB_len|\
+CBS|\
+CBS_init|\
+CBS_len|\
+CRYPTO_memcmp|\
+ECDSA_sign|\
+ECDSA_size|\
+ECDSA_verify|\
+EC_GROUP|\
+EC_GROUP_get_curve_name|\
+EC_GROUP_new_by_curve_name|\
+EC_KEY|\
+EC_KEY_free|\
+EC_KEY_generate_key|\
+EC_KEY_get0_group|\
+EC_KEY_marshal_private_key|\
+EC_KEY_new|\
+EC_KEY_parse_private_key|\
+EC_KEY_set_group|\
+EC_KEY_up_ref|\
+EC_curve_nid2nist|\
+ED25519_PRIVATE_KEY_LEN|\
+ED25519_PUBLIC_KEY_LEN|\
+ED25519_SIGNATURE_LEN|\
+ED25519_keypair|\
+ED25519_keypair_from_seed|\
+ED25519_sign|\
+ED25519_verify|\
+ERR_print_errors_cb|\
+EVP_MD|\
+EVP_PBE_scrypt|\
+EVP_PKEY|\
+EVP_PKEY_assign_EC_KEY|\
+EVP_PKEY_free|\
+EVP_PKEY_get1_EC_KEY|\
+EVP_PKEY_new|\
+EVP_PKEY_up_ref|\
+EVP_marshal_public_key|\
+EVP_parse_public_key|\
+EVP_sha1|\
+EVP_sha256|\
+EVP_sha384|\
+EVP_sha512|\
+HMAC_CTX|\
+HMAC_CTX_cleanup|\
+HMAC_CTX_init|\
+HMAC_Final|\
+HMAC_Init_ex|\
+HMAC_Update|\
+HMAC_size|\
+NID_X9_62_prime256v1|\
+NID_secp384r1|\
+NID_secp521r1|\
+RAND_bytes|\
+PKCS5_PBKDF2_HMAC|\
+SHA_CTX|\
+SHA_DIGEST_LENGTH|\
+SHA1_Final|\
+SHA1_Init|\
+SHA1_Update|\
+SHA256_CTX|\
+SHA256_DIGEST_LENGTH|\
+SHA256_Final|\
+SHA256_Init|\
+SHA256_Update|\
+SHA512_CTX|\
+SHA384_DIGEST_LENGTH|\
+SHA384_Final|\
+SHA384_Init|\
+SHA384_Update|\
+SHA512_CTX|\
+SHA512_DIGEST_LENGTH|\
+SHA512_Final|\
+SHA512_Init|\
+SHA512_Update)"
+
+# NOTE(joshlf): Currently, we don't pass --target since none of the symbols
+# we're linking against are architecture-specific (TODO: are any of them
+# word-size-specific?). If this ever becomes a problem, then the thing to do is
+# probably to generate different files for different platforms
+# (boringssl_x86_64.rs, boringssl_arm64.rs, etc) and conditionally compile them
+# depending on target.
+bindgen bindgen.h --whitelist-function "$WHITELIST" --whitelist-type "$WHITELIST" \
+ --whitelist-var "$WHITELIST" -o boringssl.rs -- -I ./boringssl/include
+
+TMP="$(mktemp)"
+
+# Prepend copyright comment, #[allow] for various warnings we don't care about,
+# and a line telling Rust to link against libcrypto.
+cat >> "$TMP" <<'EOF'
+// Copyright 2018 Google LLC
+//
+// Use of this source code is governed by an MIT-style
+// license that can be found in the LICENSE file or at
+// https://opensource.org/licenses/MIT.
+
+#![allow(non_camel_case_types)]
+#![allow(non_snake_case)]
+#![allow(non_upper_case_globals)]
+
+#[link(name = "crypto_${MAJOR}_${MINOR}_${PATCH}")] extern {}
+
+EOF
+cat boringssl.rs >> "$TMP"
+
+mv "$TMP" boringssl.rs
+rustfmt boringssl.rs
diff --git a/boringssl/boringssl b/boringssl/boringssl
new file mode 160000
index 0000000..892a31b
--- /dev/null
+++ b/boringssl/boringssl
@@ -0,0 +1 @@
+Subproject commit 892a31b5fb6f621903681f4f597156e3db3526fe
diff --git a/boringssl/boringssl.rs b/boringssl/boringssl.rs
new file mode 100644
index 0000000..714ef5f
--- /dev/null
+++ b/boringssl/boringssl.rs
@@ -0,0 +1,1219 @@
+// Copyright 2018 Google LLC
+//
+// Use of this source code is governed by an MIT-style
+// license that can be found in the LICENSE file or at
+// https://opensource.org/licenses/MIT.
+
+// Some symbols are only used with certain features enabled, so we need to
+// suppress the unused warning when those features aren't enabled.
+#![allow(unused)]
+// Only necessary for test_symbol_conflict.sh, which exposes these symbols
+// through mundane's public interface.
+#![allow(missing_docs)]
+#![allow(non_camel_case_types)]
+#![allow(non_snake_case)]
+#![allow(non_upper_case_globals)]
+
+#[link(name = "crypto_0_2_0")]
+extern "C" {}
+
+/* automatically generated by rust-bindgen */
+
+pub const ED25519_PRIVATE_KEY_LEN: u32 = 64;
+pub const ED25519_PUBLIC_KEY_LEN: u32 = 32;
+pub const ED25519_SIGNATURE_LEN: u32 = 64;
+pub const NID_X9_62_prime256v1: u32 = 415;
+pub const NID_secp384r1: u32 = 715;
+pub const NID_secp521r1: u32 = 716;
+pub const SHA_DIGEST_LENGTH: u32 = 20;
+pub const SHA256_DIGEST_LENGTH: u32 = 32;
+pub const SHA384_DIGEST_LENGTH: u32 = 48;
+pub const SHA512_DIGEST_LENGTH: u32 = 64;
+pub type CBB = cbb_st;
+pub type CBS = cbs_st;
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct dh_st {
+ _unused: [u8; 0],
+}
+pub type DH = dh_st;
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct dsa_st {
+ _unused: [u8; 0],
+}
+pub type DSA = dsa_st;
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct ec_group_st {
+ _unused: [u8; 0],
+}
+pub type EC_GROUP = ec_group_st;
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct ec_key_st {
+ _unused: [u8; 0],
+}
+pub type EC_KEY = ec_key_st;
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct engine_st {
+ _unused: [u8; 0],
+}
+pub type ENGINE = engine_st;
+pub type EVP_MD_CTX = env_md_ctx_st;
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct env_md_st {
+ _unused: [u8; 0],
+}
+pub type EVP_MD = env_md_st;
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct evp_pkey_asn1_method_st {
+ _unused: [u8; 0],
+}
+pub type EVP_PKEY_ASN1_METHOD = evp_pkey_asn1_method_st;
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct evp_pkey_ctx_st {
+ _unused: [u8; 0],
+}
+pub type EVP_PKEY_CTX = evp_pkey_ctx_st;
+pub type EVP_PKEY = evp_pkey_st;
+pub type HMAC_CTX = hmac_ctx_st;
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct rsa_st {
+ _unused: [u8; 0],
+}
+pub type RSA = rsa_st;
+pub type SHA256_CTX = sha256_state_st;
+pub type SHA512_CTX = sha512_state_st;
+pub type SHA_CTX = sha_state_st;
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct cbs_st {
+ pub data: *const u8,
+ pub len: usize,
+}
+#[test]
+fn bindgen_test_layout_cbs_st() {
+ assert_eq!(
+ ::std::mem::size_of::<cbs_st>(),
+ 16usize,
+ concat!("Size of: ", stringify!(cbs_st))
+ );
+ assert_eq!(
+ ::std::mem::align_of::<cbs_st>(),
+ 8usize,
+ concat!("Alignment of ", stringify!(cbs_st))
+ );
+ assert_eq!(
+ unsafe { &(*(::std::ptr::null::<cbs_st>())).data as *const _ as usize },
+ 0usize,
+ concat!(
+ "Offset of field: ",
+ stringify!(cbs_st),
+ "::",
+ stringify!(data)
+ )
+ );
+ assert_eq!(
+ unsafe { &(*(::std::ptr::null::<cbs_st>())).len as *const _ as usize },
+ 8usize,
+ concat!(
+ "Offset of field: ",
+ stringify!(cbs_st),
+ "::",
+ stringify!(len)
+ )
+ );
+}
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_CBS_init"]
+ pub fn CBS_init(cbs: *mut CBS, data: *const u8, len: usize);
+}
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_CBS_len"]
+ pub fn CBS_len(cbs: *const CBS) -> usize;
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct cbb_buffer_st {
+ pub buf: *mut u8,
+ pub len: usize,
+ pub cap: usize,
+ pub can_resize: ::std::os::raw::c_char,
+ pub error: ::std::os::raw::c_char,
+}
+#[test]
+fn bindgen_test_layout_cbb_buffer_st() {
+ assert_eq!(
+ ::std::mem::size_of::<cbb_buffer_st>(),
+ 32usize,
+ concat!("Size of: ", stringify!(cbb_buffer_st))
+ );
+ assert_eq!(
+ ::std::mem::align_of::<cbb_buffer_st>(),
+ 8usize,
+ concat!("Alignment of ", stringify!(cbb_buffer_st))
+ );
+ assert_eq!(
+ unsafe { &(*(::std::ptr::null::<cbb_buffer_st>())).buf as *const _ as usize },
+ 0usize,
+ concat!(
+ "Offset of field: ",
+ stringify!(cbb_buffer_st),
+ "::",
+ stringify!(buf)
+ )
+ );
+ assert_eq!(
+ unsafe { &(*(::std::ptr::null::<cbb_buffer_st>())).len as *const _ as usize },
+ 8usize,
+ concat!(
+ "Offset of field: ",
+ stringify!(cbb_buffer_st),
+ "::",
+ stringify!(len)
+ )
+ );
+ assert_eq!(
+ unsafe { &(*(::std::ptr::null::<cbb_buffer_st>())).cap as *const _ as usize },
+ 16usize,
+ concat!(
+ "Offset of field: ",
+ stringify!(cbb_buffer_st),
+ "::",
+ stringify!(cap)
+ )
+ );
+ assert_eq!(
+ unsafe { &(*(::std::ptr::null::<cbb_buffer_st>())).can_resize as *const _ as usize },
+ 24usize,
+ concat!(
+ "Offset of field: ",
+ stringify!(cbb_buffer_st),
+ "::",
+ stringify!(can_resize)
+ )
+ );
+ assert_eq!(
+ unsafe { &(*(::std::ptr::null::<cbb_buffer_st>())).error as *const _ as usize },
+ 25usize,
+ concat!(
+ "Offset of field: ",
+ stringify!(cbb_buffer_st),
+ "::",
+ stringify!(error)
+ )
+ );
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct cbb_st {
+ pub base: *mut cbb_buffer_st,
+ pub child: *mut CBB,
+ pub offset: usize,
+ pub pending_len_len: u8,
+ pub pending_is_asn1: ::std::os::raw::c_char,
+ pub is_top_level: ::std::os::raw::c_char,
+}
+#[test]
+fn bindgen_test_layout_cbb_st() {
+ assert_eq!(
+ ::std::mem::size_of::<cbb_st>(),
+ 32usize,
+ concat!("Size of: ", stringify!(cbb_st))
+ );
+ assert_eq!(
+ ::std::mem::align_of::<cbb_st>(),
+ 8usize,
+ concat!("Alignment of ", stringify!(cbb_st))
+ );
+ assert_eq!(
+ unsafe { &(*(::std::ptr::null::<cbb_st>())).base as *const _ as usize },
+ 0usize,
+ concat!(
+ "Offset of field: ",
+ stringify!(cbb_st),
+ "::",
+ stringify!(base)
+ )
+ );
+ assert_eq!(
+ unsafe { &(*(::std::ptr::null::<cbb_st>())).child as *const _ as usize },
+ 8usize,
+ concat!(
+ "Offset of field: ",
+ stringify!(cbb_st),
+ "::",
+ stringify!(child)
+ )
+ );
+ assert_eq!(
+ unsafe { &(*(::std::ptr::null::<cbb_st>())).offset as *const _ as usize },
+ 16usize,
+ concat!(
+ "Offset of field: ",
+ stringify!(cbb_st),
+ "::",
+ stringify!(offset)
+ )
+ );
+ assert_eq!(
+ unsafe { &(*(::std::ptr::null::<cbb_st>())).pending_len_len as *const _ as usize },
+ 24usize,
+ concat!(
+ "Offset of field: ",
+ stringify!(cbb_st),
+ "::",
+ stringify!(pending_len_len)
+ )
+ );
+ assert_eq!(
+ unsafe { &(*(::std::ptr::null::<cbb_st>())).pending_is_asn1 as *const _ as usize },
+ 25usize,
+ concat!(
+ "Offset of field: ",
+ stringify!(cbb_st),
+ "::",
+ stringify!(pending_is_asn1)
+ )
+ );
+ assert_eq!(
+ unsafe { &(*(::std::ptr::null::<cbb_st>())).is_top_level as *const _ as usize },
+ 26usize,
+ concat!(
+ "Offset of field: ",
+ stringify!(cbb_st),
+ "::",
+ stringify!(is_top_level)
+ )
+ );
+}
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_CBB_init"]
+ pub fn CBB_init(cbb: *mut CBB, initial_capacity: usize) -> ::std::os::raw::c_int;
+}
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_CBB_cleanup"]
+ pub fn CBB_cleanup(cbb: *mut CBB);
+}
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_CBB_data"]
+ pub fn CBB_data(cbb: *const CBB) -> *const u8;
+}
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_CBB_len"]
+ pub fn CBB_len(cbb: *const CBB) -> usize;
+}
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_ED25519_keypair"]
+ pub fn ED25519_keypair(out_public_key: *mut u8, out_private_key: *mut u8);
+}
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_ED25519_sign"]
+ pub fn ED25519_sign(
+ out_sig: *mut u8, message: *const u8, message_len: usize, private_key: *const u8,
+ ) -> ::std::os::raw::c_int;
+}
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_ED25519_verify"]
+ pub fn ED25519_verify(
+ message: *const u8, message_len: usize, signature: *const u8, public_key: *const u8,
+ ) -> ::std::os::raw::c_int;
+}
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_ED25519_keypair_from_seed"]
+ pub fn ED25519_keypair_from_seed(
+ out_public_key: *mut u8, out_private_key: *mut u8, seed: *const u8,
+ );
+}
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_EC_GROUP_new_by_curve_name"]
+ pub fn EC_GROUP_new_by_curve_name(nid: ::std::os::raw::c_int) -> *mut EC_GROUP;
+}
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_EC_GROUP_get_curve_name"]
+ pub fn EC_GROUP_get_curve_name(group: *const EC_GROUP) -> ::std::os::raw::c_int;
+}
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_EC_curve_nid2nist"]
+ pub fn EC_curve_nid2nist(nid: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char;
+}
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_EC_KEY_new"]
+ pub fn EC_KEY_new() -> *mut EC_KEY;
+}
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_EC_KEY_free"]
+ pub fn EC_KEY_free(key: *mut EC_KEY);
+}
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_EC_KEY_up_ref"]
+ pub fn EC_KEY_up_ref(key: *mut EC_KEY) -> ::std::os::raw::c_int;
+}
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_EC_KEY_get0_group"]
+ pub fn EC_KEY_get0_group(key: *const EC_KEY) -> *const EC_GROUP;
+}
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_EC_KEY_set_group"]
+ pub fn EC_KEY_set_group(key: *mut EC_KEY, group: *const EC_GROUP) -> ::std::os::raw::c_int;
+}
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_EC_KEY_generate_key"]
+ pub fn EC_KEY_generate_key(key: *mut EC_KEY) -> ::std::os::raw::c_int;
+}
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_EC_KEY_parse_private_key"]
+ pub fn EC_KEY_parse_private_key(cbs: *mut CBS, group: *const EC_GROUP) -> *mut EC_KEY;
+}
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_EC_KEY_marshal_private_key"]
+ pub fn EC_KEY_marshal_private_key(
+ cbb: *mut CBB, key: *const EC_KEY, enc_flags: ::std::os::raw::c_uint,
+ ) -> ::std::os::raw::c_int;
+}
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_ECDSA_sign"]
+ pub fn ECDSA_sign(
+ type_: ::std::os::raw::c_int, digest: *const u8, digest_len: usize, sig: *mut u8,
+ sig_len: *mut ::std::os::raw::c_uint, key: *const EC_KEY,
+ ) -> ::std::os::raw::c_int;
+}
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_ECDSA_verify"]
+ pub fn ECDSA_verify(
+ type_: ::std::os::raw::c_int, digest: *const u8, digest_len: usize, sig: *const u8,
+ sig_len: usize, key: *const EC_KEY,
+ ) -> ::std::os::raw::c_int;
+}
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_ECDSA_size"]
+ pub fn ECDSA_size(key: *const EC_KEY) -> usize;
+}
+pub type ERR_print_errors_callback_t = ::std::option::Option<
+ unsafe extern "C" fn(
+ str: *const ::std::os::raw::c_char,
+ len: usize,
+ ctx: *mut ::std::os::raw::c_void,
+ ) -> ::std::os::raw::c_int,
+>;
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_ERR_print_errors_cb"]
+ pub fn ERR_print_errors_cb(
+ callback: ERR_print_errors_callback_t, ctx: *mut ::std::os::raw::c_void,
+ );
+}
+pub type CRYPTO_refcount_t = u32;
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_EVP_sha1"]
+ pub fn EVP_sha1() -> *const EVP_MD;
+}
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_EVP_sha256"]
+ pub fn EVP_sha256() -> *const EVP_MD;
+}
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_EVP_sha384"]
+ pub fn EVP_sha384() -> *const EVP_MD;
+}
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_EVP_sha512"]
+ pub fn EVP_sha512() -> *const EVP_MD;
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct evp_md_pctx_ops {
+ _unused: [u8; 0],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct env_md_ctx_st {
+ pub digest: *const EVP_MD,
+ pub md_data: *mut ::std::os::raw::c_void,
+ pub pctx: *mut EVP_PKEY_CTX,
+ pub pctx_ops: *const evp_md_pctx_ops,
+}
+#[test]
+fn bindgen_test_layout_env_md_ctx_st() {
+ assert_eq!(
+ ::std::mem::size_of::<env_md_ctx_st>(),
+ 32usize,
+ concat!("Size of: ", stringify!(env_md_ctx_st))
+ );
+ assert_eq!(
+ ::std::mem::align_of::<env_md_ctx_st>(),
+ 8usize,
+ concat!("Alignment of ", stringify!(env_md_ctx_st))
+ );
+ assert_eq!(
+ unsafe { &(*(::std::ptr::null::<env_md_ctx_st>())).digest as *const _ as usize },
+ 0usize,
+ concat!(
+ "Offset of field: ",
+ stringify!(env_md_ctx_st),
+ "::",
+ stringify!(digest)
+ )
+ );
+ assert_eq!(
+ unsafe { &(*(::std::ptr::null::<env_md_ctx_st>())).md_data as *const _ as usize },
+ 8usize,
+ concat!(
+ "Offset of field: ",
+ stringify!(env_md_ctx_st),
+ "::",
+ stringify!(md_data)
+ )
+ );
+ assert_eq!(
+ unsafe { &(*(::std::ptr::null::<env_md_ctx_st>())).pctx as *const _ as usize },
+ 16usize,
+ concat!(
+ "Offset of field: ",
+ stringify!(env_md_ctx_st),
+ "::",
+ stringify!(pctx)
+ )
+ );
+ assert_eq!(
+ unsafe { &(*(::std::ptr::null::<env_md_ctx_st>())).pctx_ops as *const _ as usize },
+ 24usize,
+ concat!(
+ "Offset of field: ",
+ stringify!(env_md_ctx_st),
+ "::",
+ stringify!(pctx_ops)
+ )
+ );
+}
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_EVP_PKEY_new"]
+ pub fn EVP_PKEY_new() -> *mut EVP_PKEY;
+}
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_EVP_PKEY_free"]
+ pub fn EVP_PKEY_free(pkey: *mut EVP_PKEY);
+}
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_EVP_PKEY_up_ref"]
+ pub fn EVP_PKEY_up_ref(pkey: *mut EVP_PKEY) -> ::std::os::raw::c_int;
+}
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_EVP_PKEY_assign_EC_KEY"]
+ pub fn EVP_PKEY_assign_EC_KEY(pkey: *mut EVP_PKEY, key: *mut EC_KEY) -> ::std::os::raw::c_int;
+}
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_EVP_PKEY_get1_EC_KEY"]
+ pub fn EVP_PKEY_get1_EC_KEY(pkey: *const EVP_PKEY) -> *mut EC_KEY;
+}
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_EVP_parse_public_key"]
+ pub fn EVP_parse_public_key(cbs: *mut CBS) -> *mut EVP_PKEY;
+}
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_EVP_marshal_public_key"]
+ pub fn EVP_marshal_public_key(cbb: *mut CBB, key: *const EVP_PKEY) -> ::std::os::raw::c_int;
+}
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_PKCS5_PBKDF2_HMAC"]
+ pub fn PKCS5_PBKDF2_HMAC(
+ password: *const ::std::os::raw::c_char, password_len: usize, salt: *const u8,
+ salt_len: usize, iterations: ::std::os::raw::c_uint, digest: *const EVP_MD, key_len: usize,
+ out_key: *mut u8,
+ ) -> ::std::os::raw::c_int;
+}
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_EVP_PBE_scrypt"]
+ pub fn EVP_PBE_scrypt(
+ password: *const ::std::os::raw::c_char, password_len: usize, salt: *const u8,
+ salt_len: usize, N: u64, r: u64, p: u64, max_mem: usize, out_key: *mut u8, key_len: usize,
+ ) -> ::std::os::raw::c_int;
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct evp_pkey_st {
+ pub references: CRYPTO_refcount_t,
+ pub type_: ::std::os::raw::c_int,
+ pub pkey: evp_pkey_st__bindgen_ty_1,
+ pub ameth: *const EVP_PKEY_ASN1_METHOD,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union evp_pkey_st__bindgen_ty_1 {
+ pub ptr: *mut ::std::os::raw::c_void,
+ pub rsa: *mut RSA,
+ pub dsa: *mut DSA,
+ pub dh: *mut DH,
+ pub ec: *mut EC_KEY,
+ _bindgen_union_align: u64,
+}
+#[test]
+fn bindgen_test_layout_evp_pkey_st__bindgen_ty_1() {
+ assert_eq!(
+ ::std::mem::size_of::<evp_pkey_st__bindgen_ty_1>(),
+ 8usize,
+ concat!("Size of: ", stringify!(evp_pkey_st__bindgen_ty_1))
+ );
+ assert_eq!(
+ ::std::mem::align_of::<evp_pkey_st__bindgen_ty_1>(),
+ 8usize,
+ concat!("Alignment of ", stringify!(evp_pkey_st__bindgen_ty_1))
+ );
+ assert_eq!(
+ unsafe { &(*(::std::ptr::null::<evp_pkey_st__bindgen_ty_1>())).ptr as *const _ as usize },
+ 0usize,
+ concat!(
+ "Offset of field: ",
+ stringify!(evp_pkey_st__bindgen_ty_1),
+ "::",
+ stringify!(ptr)
+ )
+ );
+ assert_eq!(
+ unsafe { &(*(::std::ptr::null::<evp_pkey_st__bindgen_ty_1>())).rsa as *const _ as usize },
+ 0usize,
+ concat!(
+ "Offset of field: ",
+ stringify!(evp_pkey_st__bindgen_ty_1),
+ "::",
+ stringify!(rsa)
+ )
+ );
+ assert_eq!(
+ unsafe { &(*(::std::ptr::null::<evp_pkey_st__bindgen_ty_1>())).dsa as *const _ as usize },
+ 0usize,
+ concat!(
+ "Offset of field: ",
+ stringify!(evp_pkey_st__bindgen_ty_1),
+ "::",
+ stringify!(dsa)
+ )
+ );
+ assert_eq!(
+ unsafe { &(*(::std::ptr::null::<evp_pkey_st__bindgen_ty_1>())).dh as *const _ as usize },
+ 0usize,
+ concat!(
+ "Offset of field: ",
+ stringify!(evp_pkey_st__bindgen_ty_1),
+ "::",
+ stringify!(dh)
+ )
+ );
+ assert_eq!(
+ unsafe { &(*(::std::ptr::null::<evp_pkey_st__bindgen_ty_1>())).ec as *const _ as usize },
+ 0usize,
+ concat!(
+ "Offset of field: ",
+ stringify!(evp_pkey_st__bindgen_ty_1),
+ "::",
+ stringify!(ec)
+ )
+ );
+}
+#[test]
+fn bindgen_test_layout_evp_pkey_st() {
+ assert_eq!(
+ ::std::mem::size_of::<evp_pkey_st>(),
+ 24usize,
+ concat!("Size of: ", stringify!(evp_pkey_st))
+ );
+ assert_eq!(
+ ::std::mem::align_of::<evp_pkey_st>(),
+ 8usize,
+ concat!("Alignment of ", stringify!(evp_pkey_st))
+ );
+ assert_eq!(
+ unsafe { &(*(::std::ptr::null::<evp_pkey_st>())).references as *const _ as usize },
+ 0usize,
+ concat!(
+ "Offset of field: ",
+ stringify!(evp_pkey_st),
+ "::",
+ stringify!(references)
+ )
+ );
+ assert_eq!(
+ unsafe { &(*(::std::ptr::null::<evp_pkey_st>())).type_ as *const _ as usize },
+ 4usize,
+ concat!(
+ "Offset of field: ",
+ stringify!(evp_pkey_st),
+ "::",
+ stringify!(type_)
+ )
+ );
+ assert_eq!(
+ unsafe { &(*(::std::ptr::null::<evp_pkey_st>())).pkey as *const _ as usize },
+ 8usize,
+ concat!(
+ "Offset of field: ",
+ stringify!(evp_pkey_st),
+ "::",
+ stringify!(pkey)
+ )
+ );
+ assert_eq!(
+ unsafe { &(*(::std::ptr::null::<evp_pkey_st>())).ameth as *const _ as usize },
+ 16usize,
+ concat!(
+ "Offset of field: ",
+ stringify!(evp_pkey_st),
+ "::",
+ stringify!(ameth)
+ )
+ );
+}
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_HMAC_CTX_init"]
+ pub fn HMAC_CTX_init(ctx: *mut HMAC_CTX);
+}
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_HMAC_CTX_cleanup"]
+ pub fn HMAC_CTX_cleanup(ctx: *mut HMAC_CTX);
+}
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_HMAC_Init_ex"]
+ pub fn HMAC_Init_ex(
+ ctx: *mut HMAC_CTX, key: *const ::std::os::raw::c_void, key_len: usize, md: *const EVP_MD,
+ impl_: *mut ENGINE,
+ ) -> ::std::os::raw::c_int;
+}
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_HMAC_Update"]
+ pub fn HMAC_Update(
+ ctx: *mut HMAC_CTX, data: *const u8, data_len: usize,
+ ) -> ::std::os::raw::c_int;
+}
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_HMAC_Final"]
+ pub fn HMAC_Final(
+ ctx: *mut HMAC_CTX, out: *mut u8, out_len: *mut ::std::os::raw::c_uint,
+ ) -> ::std::os::raw::c_int;
+}
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_HMAC_size"]
+ pub fn HMAC_size(ctx: *const HMAC_CTX) -> usize;
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct hmac_ctx_st {
+ pub md: *const EVP_MD,
+ pub md_ctx: EVP_MD_CTX,
+ pub i_ctx: EVP_MD_CTX,
+ pub o_ctx: EVP_MD_CTX,
+}
+#[test]
+fn bindgen_test_layout_hmac_ctx_st() {
+ assert_eq!(
+ ::std::mem::size_of::<hmac_ctx_st>(),
+ 104usize,
+ concat!("Size of: ", stringify!(hmac_ctx_st))
+ );
+ assert_eq!(
+ ::std::mem::align_of::<hmac_ctx_st>(),
+ 8usize,
+ concat!("Alignment of ", stringify!(hmac_ctx_st))
+ );
+ assert_eq!(
+ unsafe { &(*(::std::ptr::null::<hmac_ctx_st>())).md as *const _ as usize },
+ 0usize,
+ concat!(
+ "Offset of field: ",
+ stringify!(hmac_ctx_st),
+ "::",
+ stringify!(md)
+ )
+ );
+ assert_eq!(
+ unsafe { &(*(::std::ptr::null::<hmac_ctx_st>())).md_ctx as *const _ as usize },
+ 8usize,
+ concat!(
+ "Offset of field: ",
+ stringify!(hmac_ctx_st),
+ "::",
+ stringify!(md_ctx)
+ )
+ );
+ assert_eq!(
+ unsafe { &(*(::std::ptr::null::<hmac_ctx_st>())).i_ctx as *const _ as usize },
+ 40usize,
+ concat!(
+ "Offset of field: ",
+ stringify!(hmac_ctx_st),
+ "::",
+ stringify!(i_ctx)
+ )
+ );
+ assert_eq!(
+ unsafe { &(*(::std::ptr::null::<hmac_ctx_st>())).o_ctx as *const _ as usize },
+ 72usize,
+ concat!(
+ "Offset of field: ",
+ stringify!(hmac_ctx_st),
+ "::",
+ stringify!(o_ctx)
+ )
+ );
+}
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_CRYPTO_memcmp"]
+ pub fn CRYPTO_memcmp(
+ a: *const ::std::os::raw::c_void, b: *const ::std::os::raw::c_void, len: usize,
+ ) -> ::std::os::raw::c_int;
+}
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_RAND_bytes"]
+ pub fn RAND_bytes(buf: *mut u8, len: usize) -> ::std::os::raw::c_int;
+}
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_SHA1_Init"]
+ pub fn SHA1_Init(sha: *mut SHA_CTX) -> ::std::os::raw::c_int;
+}
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_SHA1_Update"]
+ pub fn SHA1_Update(
+ sha: *mut SHA_CTX, data: *const ::std::os::raw::c_void, len: usize,
+ ) -> ::std::os::raw::c_int;
+}
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_SHA1_Final"]
+ pub fn SHA1_Final(md: *mut u8, sha: *mut SHA_CTX) -> ::std::os::raw::c_int;
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct sha_state_st {
+ pub __bindgen_anon_1: sha_state_st__bindgen_ty_1,
+ pub Nl: u32,
+ pub Nh: u32,
+ pub data: [u8; 64usize],
+ pub num: ::std::os::raw::c_uint,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union sha_state_st__bindgen_ty_1 {
+ pub h: [u32; 5usize],
+ pub __bindgen_anon_1: sha_state_st__bindgen_ty_1__bindgen_ty_1,
+ _bindgen_union_align: [u32; 5usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct sha_state_st__bindgen_ty_1__bindgen_ty_1 {
+ pub h0: u32,
+ pub h1: u32,
+ pub h2: u32,
+ pub h3: u32,
+ pub h4: u32,
+}
+#[test]
+fn bindgen_test_layout_sha_state_st__bindgen_ty_1__bindgen_ty_1() {
+ assert_eq!(
+ ::std::mem::size_of::<sha_state_st__bindgen_ty_1__bindgen_ty_1>(),
+ 20usize,
+ concat!(
+ "Size of: ",
+ stringify!(sha_state_st__bindgen_ty_1__bindgen_ty_1)
+ )
+ );
+ assert_eq!(
+ ::std::mem::align_of::<sha_state_st__bindgen_ty_1__bindgen_ty_1>(),
+ 4usize,
+ concat!(
+ "Alignment of ",
+ stringify!(sha_state_st__bindgen_ty_1__bindgen_ty_1)
+ )
+ );
+ assert_eq!(
+ unsafe {
+ &(*(::std::ptr::null::<sha_state_st__bindgen_ty_1__bindgen_ty_1>())).h0 as *const _
+ as usize
+ },
+ 0usize,
+ concat!(
+ "Offset of field: ",
+ stringify!(sha_state_st__bindgen_ty_1__bindgen_ty_1),
+ "::",
+ stringify!(h0)
+ )
+ );
+ assert_eq!(
+ unsafe {
+ &(*(::std::ptr::null::<sha_state_st__bindgen_ty_1__bindgen_ty_1>())).h1 as *const _
+ as usize
+ },
+ 4usize,
+ concat!(
+ "Offset of field: ",
+ stringify!(sha_state_st__bindgen_ty_1__bindgen_ty_1),
+ "::",
+ stringify!(h1)
+ )
+ );
+ assert_eq!(
+ unsafe {
+ &(*(::std::ptr::null::<sha_state_st__bindgen_ty_1__bindgen_ty_1>())).h2 as *const _
+ as usize
+ },
+ 8usize,
+ concat!(
+ "Offset of field: ",
+ stringify!(sha_state_st__bindgen_ty_1__bindgen_ty_1),
+ "::",
+ stringify!(h2)
+ )
+ );
+ assert_eq!(
+ unsafe {
+ &(*(::std::ptr::null::<sha_state_st__bindgen_ty_1__bindgen_ty_1>())).h3 as *const _
+ as usize
+ },
+ 12usize,
+ concat!(
+ "Offset of field: ",
+ stringify!(sha_state_st__bindgen_ty_1__bindgen_ty_1),
+ "::",
+ stringify!(h3)
+ )
+ );
+ assert_eq!(
+ unsafe {
+ &(*(::std::ptr::null::<sha_state_st__bindgen_ty_1__bindgen_ty_1>())).h4 as *const _
+ as usize
+ },
+ 16usize,
+ concat!(
+ "Offset of field: ",
+ stringify!(sha_state_st__bindgen_ty_1__bindgen_ty_1),
+ "::",
+ stringify!(h4)
+ )
+ );
+}
+#[test]
+fn bindgen_test_layout_sha_state_st__bindgen_ty_1() {
+ assert_eq!(
+ ::std::mem::size_of::<sha_state_st__bindgen_ty_1>(),
+ 20usize,
+ concat!("Size of: ", stringify!(sha_state_st__bindgen_ty_1))
+ );
+ assert_eq!(
+ ::std::mem::align_of::<sha_state_st__bindgen_ty_1>(),
+ 4usize,
+ concat!("Alignment of ", stringify!(sha_state_st__bindgen_ty_1))
+ );
+ assert_eq!(
+ unsafe { &(*(::std::ptr::null::<sha_state_st__bindgen_ty_1>())).h as *const _ as usize },
+ 0usize,
+ concat!(
+ "Offset of field: ",
+ stringify!(sha_state_st__bindgen_ty_1),
+ "::",
+ stringify!(h)
+ )
+ );
+}
+#[test]
+fn bindgen_test_layout_sha_state_st() {
+ assert_eq!(
+ ::std::mem::size_of::<sha_state_st>(),
+ 96usize,
+ concat!("Size of: ", stringify!(sha_state_st))
+ );
+ assert_eq!(
+ ::std::mem::align_of::<sha_state_st>(),
+ 4usize,
+ concat!("Alignment of ", stringify!(sha_state_st))
+ );
+ assert_eq!(
+ unsafe { &(*(::std::ptr::null::<sha_state_st>())).Nl as *const _ as usize },
+ 20usize,
+ concat!(
+ "Offset of field: ",
+ stringify!(sha_state_st),
+ "::",
+ stringify!(Nl)
+ )
+ );
+ assert_eq!(
+ unsafe { &(*(::std::ptr::null::<sha_state_st>())).Nh as *const _ as usize },
+ 24usize,
+ concat!(
+ "Offset of field: ",
+ stringify!(sha_state_st),
+ "::",
+ stringify!(Nh)
+ )
+ );
+ assert_eq!(
+ unsafe { &(*(::std::ptr::null::<sha_state_st>())).data as *const _ as usize },
+ 28usize,
+ concat!(
+ "Offset of field: ",
+ stringify!(sha_state_st),
+ "::",
+ stringify!(data)
+ )
+ );
+ assert_eq!(
+ unsafe { &(*(::std::ptr::null::<sha_state_st>())).num as *const _ as usize },
+ 92usize,
+ concat!(
+ "Offset of field: ",
+ stringify!(sha_state_st),
+ "::",
+ stringify!(num)
+ )
+ );
+}
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_SHA256_Init"]
+ pub fn SHA256_Init(sha: *mut SHA256_CTX) -> ::std::os::raw::c_int;
+}
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_SHA256_Update"]
+ pub fn SHA256_Update(
+ sha: *mut SHA256_CTX, data: *const ::std::os::raw::c_void, len: usize,
+ ) -> ::std::os::raw::c_int;
+}
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_SHA256_Final"]
+ pub fn SHA256_Final(md: *mut u8, sha: *mut SHA256_CTX) -> ::std::os::raw::c_int;
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct sha256_state_st {
+ pub h: [u32; 8usize],
+ pub Nl: u32,
+ pub Nh: u32,
+ pub data: [u8; 64usize],
+ pub num: ::std::os::raw::c_uint,
+ pub md_len: ::std::os::raw::c_uint,
+}
+#[test]
+fn bindgen_test_layout_sha256_state_st() {
+ assert_eq!(
+ ::std::mem::size_of::<sha256_state_st>(),
+ 112usize,
+ concat!("Size of: ", stringify!(sha256_state_st))
+ );
+ assert_eq!(
+ ::std::mem::align_of::<sha256_state_st>(),
+ 4usize,
+ concat!("Alignment of ", stringify!(sha256_state_st))
+ );
+ assert_eq!(
+ unsafe { &(*(::std::ptr::null::<sha256_state_st>())).h as *const _ as usize },
+ 0usize,
+ concat!(
+ "Offset of field: ",
+ stringify!(sha256_state_st),
+ "::",
+ stringify!(h)
+ )
+ );
+ assert_eq!(
+ unsafe { &(*(::std::ptr::null::<sha256_state_st>())).Nl as *const _ as usize },
+ 32usize,
+ concat!(
+ "Offset of field: ",
+ stringify!(sha256_state_st),
+ "::",
+ stringify!(Nl)
+ )
+ );
+ assert_eq!(
+ unsafe { &(*(::std::ptr::null::<sha256_state_st>())).Nh as *const _ as usize },
+ 36usize,
+ concat!(
+ "Offset of field: ",
+ stringify!(sha256_state_st),
+ "::",
+ stringify!(Nh)
+ )
+ );
+ assert_eq!(
+ unsafe { &(*(::std::ptr::null::<sha256_state_st>())).data as *const _ as usize },
+ 40usize,
+ concat!(
+ "Offset of field: ",
+ stringify!(sha256_state_st),
+ "::",
+ stringify!(data)
+ )
+ );
+ assert_eq!(
+ unsafe { &(*(::std::ptr::null::<sha256_state_st>())).num as *const _ as usize },
+ 104usize,
+ concat!(
+ "Offset of field: ",
+ stringify!(sha256_state_st),
+ "::",
+ stringify!(num)
+ )
+ );
+ assert_eq!(
+ unsafe { &(*(::std::ptr::null::<sha256_state_st>())).md_len as *const _ as usize },
+ 108usize,
+ concat!(
+ "Offset of field: ",
+ stringify!(sha256_state_st),
+ "::",
+ stringify!(md_len)
+ )
+ );
+}
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_SHA384_Init"]
+ pub fn SHA384_Init(sha: *mut SHA512_CTX) -> ::std::os::raw::c_int;
+}
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_SHA384_Update"]
+ pub fn SHA384_Update(
+ sha: *mut SHA512_CTX, data: *const ::std::os::raw::c_void, len: usize,
+ ) -> ::std::os::raw::c_int;
+}
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_SHA384_Final"]
+ pub fn SHA384_Final(md: *mut u8, sha: *mut SHA512_CTX) -> ::std::os::raw::c_int;
+}
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_SHA512_Init"]
+ pub fn SHA512_Init(sha: *mut SHA512_CTX) -> ::std::os::raw::c_int;
+}
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_SHA512_Update"]
+ pub fn SHA512_Update(
+ sha: *mut SHA512_CTX, data: *const ::std::os::raw::c_void, len: usize,
+ ) -> ::std::os::raw::c_int;
+}
+extern "C" {
+ #[link_name = "__RUST_MUNDANE_0_2_0_SHA512_Final"]
+ pub fn SHA512_Final(md: *mut u8, sha: *mut SHA512_CTX) -> ::std::os::raw::c_int;
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct sha512_state_st {
+ pub h: [u64; 8usize],
+ pub Nl: u64,
+ pub Nh: u64,
+ pub u: sha512_state_st__bindgen_ty_1,
+ pub num: ::std::os::raw::c_uint,
+ pub md_len: ::std::os::raw::c_uint,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union sha512_state_st__bindgen_ty_1 {
+ pub d: [u64; 16usize],
+ pub p: [u8; 128usize],
+ _bindgen_union_align: [u64; 16usize],
+}
+#[test]
+fn bindgen_test_layout_sha512_state_st__bindgen_ty_1() {
+ assert_eq!(
+ ::std::mem::size_of::<sha512_state_st__bindgen_ty_1>(),
+ 128usize,
+ concat!("Size of: ", stringify!(sha512_state_st__bindgen_ty_1))
+ );
+ assert_eq!(
+ ::std::mem::align_of::<sha512_state_st__bindgen_ty_1>(),
+ 8usize,
+ concat!("Alignment of ", stringify!(sha512_state_st__bindgen_ty_1))
+ );
+ assert_eq!(
+ unsafe { &(*(::std::ptr::null::<sha512_state_st__bindgen_ty_1>())).d as *const _ as usize },
+ 0usize,
+ concat!(
+ "Offset of field: ",
+ stringify!(sha512_state_st__bindgen_ty_1),
+ "::",
+ stringify!(d)
+ )
+ );
+ assert_eq!(
+ unsafe { &(*(::std::ptr::null::<sha512_state_st__bindgen_ty_1>())).p as *const _ as usize },
+ 0usize,
+ concat!(
+ "Offset of field: ",
+ stringify!(sha512_state_st__bindgen_ty_1),
+ "::",
+ stringify!(p)
+ )
+ );
+}
+#[test]
+fn bindgen_test_layout_sha512_state_st() {
+ assert_eq!(
+ ::std::mem::size_of::<sha512_state_st>(),
+ 216usize,
+ concat!("Size of: ", stringify!(sha512_state_st))
+ );
+ assert_eq!(
+ ::std::mem::align_of::<sha512_state_st>(),
+ 8usize,
+ concat!("Alignment of ", stringify!(sha512_state_st))
+ );
+ assert_eq!(
+ unsafe { &(*(::std::ptr::null::<sha512_state_st>())).h as *const _ as usize },
+ 0usize,
+ concat!(
+ "Offset of field: ",
+ stringify!(sha512_state_st),
+ "::",
+ stringify!(h)
+ )
+ );
+ assert_eq!(
+ unsafe { &(*(::std::ptr::null::<sha512_state_st>())).Nl as *const _ as usize },
+ 64usize,
+ concat!(
+ "Offset of field: ",
+ stringify!(sha512_state_st),
+ "::",
+ stringify!(Nl)
+ )
+ );
+ assert_eq!(
+ unsafe { &(*(::std::ptr::null::<sha512_state_st>())).Nh as *const _ as usize },
+ 72usize,
+ concat!(
+ "Offset of field: ",
+ stringify!(sha512_state_st),
+ "::",
+ stringify!(Nh)
+ )
+ );
+ assert_eq!(
+ unsafe { &(*(::std::ptr::null::<sha512_state_st>())).u as *const _ as usize },
+ 80usize,
+ concat!(
+ "Offset of field: ",
+ stringify!(sha512_state_st),
+ "::",
+ stringify!(u)
+ )
+ );
+ assert_eq!(
+ unsafe { &(*(::std::ptr::null::<sha512_state_st>())).num as *const _ as usize },
+ 208usize,
+ concat!(
+ "Offset of field: ",
+ stringify!(sha512_state_st),
+ "::",
+ stringify!(num)
+ )
+ );
+ assert_eq!(
+ unsafe { &(*(::std::ptr::null::<sha512_state_st>())).md_len as *const _ as usize },
+ 212usize,
+ concat!(
+ "Offset of field: ",
+ stringify!(sha512_state_st),
+ "::",
+ stringify!(md_len)
+ )
+ );
+}
diff --git a/boringssl/test_symbol_conflict.sh b/boringssl/test_symbol_conflict.sh
new file mode 100755
index 0000000..15a0f14
--- /dev/null
+++ b/boringssl/test_symbol_conflict.sh
@@ -0,0 +1,238 @@
+#!/bin/bash
+
+# Copyright 2018 Google LLC
+#
+# Use of this source code is governed by an MIT-style
+# license that can be found in the LICENSE file or at
+# https://opensource.org/licenses/MIT.
+
+# This script tests that a build with multiple versions of the mundane crate in
+# the same build graph works properly. It performs the following steps:
+# - Create a temporary directory
+# - Create two copies of mundane - mundane-v1, and mundane-v2 - which directly
+# expose the boringssl::ffi module so that dependent crates can access the raw
+# symbols
+# - Create two crates, one depending on mundane-v1, and one on mundane-v2, each
+# of which exposes all of the BoringSSL symbols from mundane
+# - Create a top-level program which depends on both of these crates
+# - Have the top-level program's main call all of the mundane functions from
+# each of the crates
+# - Produce a release build, which forces linking, to make sure that linking
+# these two versions of the library at the same time works properly
+
+set -e
+
+# the directory this script lives in
+readonly SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+CRATE_ROOT="${SCRIPT_DIR}/.."
+
+TMP="$(mktemp -d)"
+cd "$TMP"
+
+# NOTE: The -L means to follow symlinks
+cp -LR "$CRATE_ROOT" mundane-v1
+cp -LR "$CRATE_ROOT" mundane-v2
+echo "$TMP"
+
+#
+# Make mundane crates
+#
+
+# Update the Cargo.toml versions and names in place to be distinct
+sed -i '' -e 's/^name =.*/name = "mundane-v1"/' mundane-v1/Cargo.toml
+sed -i '' -e 's/^version =.*/version = "1.0.0"/' mundane-v1/Cargo.toml
+sed -i '' -e 's/^name =.*/name = "mundane-v2"/' mundane-v2/Cargo.toml
+sed -i '' -e 's/^version =.*/version = "2.0.0"/' mundane-v2/Cargo.toml
+
+# Update the link directive to use the right version number
+sed -i '' -e 's/#[link(name = "crypto_[0-9]*_[0-9]*_[0-9]*")]/#[link(name = "crypto_1_0_0")]/' mundane-v1/boringssl/boringssl.rs
+sed -i '' -e 's/#[link(name = "crypto_[0-9]*_[0-9]*_[0-9]*")]/#[link(name = "crypto_2_0_0")]/' mundane-v2/boringssl/boringssl.rs
+# Update the link_name directives to use the right version number
+sed -i '' -e 's/__RUST_MUNDANE_[0-9]*_[0-9]*_[0-9]*_/__RUST_MUNDANE_1_0_0_/' mundane-v1/boringssl/boringssl.rs
+sed -i '' -e 's/__RUST_MUNDANE_[0-9]*_[0-9]*_[0-9]*_/__RUST_MUNDANE_2_0_0_/' mundane-v2/boringssl/boringssl.rs
+# Mark the ffi module as public
+sed -i '' -e 's/^mod ffi;$/pub mod ffi;/' mundane-v1/src/boringssl/mod.rs
+sed -i '' -e 's/^mod ffi;$/pub mod ffi;/' mundane-v2/src/boringssl/mod.rs
+# Make mundane directly expose the ffi module
+echo "pub use boringssl::ffi;" >> mundane-v1/src/lib.rs
+echo "pub use boringssl::ffi;" >> mundane-v2/src/lib.rs
+
+#
+# Make crates which depend on mundane
+#
+
+# Usage: make_crate <crate name> <dep name>
+function make_crate {
+ CRATE_NAME="$1"
+ DEP_NAME="$2"
+ DEP_NAME_RS="$(echo ${DEP_NAME} | tr - _)"
+
+ mkdir "$CRATE_NAME"
+ mkdir "${CRATE_NAME}/src"
+ # Re-export all symbols from mundane
+ cat >> "${CRATE_NAME}/src/lib.rs" <<EOF
+extern crate ${DEP_NAME_RS};
+
+pub use ${DEP_NAME_RS}::ffi::*;
+EOF
+
+ cat >> "${CRATE_NAME}/Cargo.toml" <<EOF
+[package]
+name = "${CRATE_NAME}"
+version = "0.0.0"
+
+[dependencies]
+${DEP_NAME} = { path = "../${DEP_NAME}" }
+EOF
+}
+
+make_crate depends-mundane-v1 mundane-v1
+make_crate depends-mundane-v2 mundane-v2
+
+#
+# Make top-level crate
+#
+
+cat >> Cargo.toml <<EOF
+[package]
+name = "mundane-version-test"
+version = "0.0.0"
+
+[dependencies]
+depends-mundane-v1 = { path = "./depends-mundane-v1" }
+depends-mundane-v2 = { path = "./depends-mundane-v2" }
+EOF
+
+# The body of main() is generated with the following scripts:
+# rg -U 'extern "C" \{\n[^\n]*\n pub fn [0-9A-Za-z_]*([^)]*)' boringssl.rs | grep '^ *pub fn' | sed -e 's/.*pub fn \([^(]*\).*/println!("{:?}", depends_mundane_v1::\1 as *const ());/'
+# rg -U 'extern "C" \{\n[^\n]*\n pub fn [0-9A-Za-z_]*([^)]*)' boringssl.rs | grep '^ *pub fn' | sed -e 's/.*pub fn \([^(]*\).*/println!("{:?}", depends_mundane_v2::\1 as *const ());/'
+
+mkdir src
+cat >> src/main.rs <<EOF
+extern crate depends_mundane_v1;
+extern crate depends_mundane_v2;
+
+fn main() {
+println!("{:?}", depends_mundane_v1::ERR_print_errors_cb as *const ());
+println!("{:?}", depends_mundane_v1::CBS_init as *const ());
+println!("{:?}", depends_mundane_v1::CBS_len as *const ());
+println!("{:?}", depends_mundane_v1::CBB_init as *const ());
+println!("{:?}", depends_mundane_v1::CBB_cleanup as *const ());
+println!("{:?}", depends_mundane_v1::CBB_data as *const ());
+println!("{:?}", depends_mundane_v1::CBB_len as *const ());
+println!("{:?}", depends_mundane_v1::ED25519_keypair as *const ());
+println!("{:?}", depends_mundane_v1::ED25519_sign as *const ());
+println!("{:?}", depends_mundane_v1::ED25519_verify as *const ());
+println!("{:?}", depends_mundane_v1::ED25519_keypair_from_seed as *const ());
+println!("{:?}", depends_mundane_v1::EVP_sha1 as *const ());
+println!("{:?}", depends_mundane_v1::EVP_sha256 as *const ());
+println!("{:?}", depends_mundane_v1::EVP_sha384 as *const ());
+println!("{:?}", depends_mundane_v1::EVP_sha512 as *const ());
+println!("{:?}", depends_mundane_v1::EC_GROUP_new_by_curve_name as *const ());
+println!("{:?}", depends_mundane_v1::EC_GROUP_get_curve_name as *const ());
+println!("{:?}", depends_mundane_v1::EC_curve_nid2nist as *const ());
+println!("{:?}", depends_mundane_v1::EC_KEY_new as *const ());
+println!("{:?}", depends_mundane_v1::EC_KEY_free as *const ());
+println!("{:?}", depends_mundane_v1::EC_KEY_up_ref as *const ());
+println!("{:?}", depends_mundane_v1::EC_KEY_get0_group as *const ());
+println!("{:?}", depends_mundane_v1::EC_KEY_set_group as *const ());
+println!("{:?}", depends_mundane_v1::EC_KEY_generate_key as *const ());
+println!("{:?}", depends_mundane_v1::EC_KEY_parse_private_key as *const ());
+println!("{:?}", depends_mundane_v1::EC_KEY_marshal_private_key as *const ());
+println!("{:?}", depends_mundane_v1::ECDSA_sign as *const ());
+println!("{:?}", depends_mundane_v1::ECDSA_verify as *const ());
+println!("{:?}", depends_mundane_v1::ECDSA_size as *const ());
+println!("{:?}", depends_mundane_v1::EVP_PKEY_new as *const ());
+println!("{:?}", depends_mundane_v1::EVP_PKEY_free as *const ());
+println!("{:?}", depends_mundane_v1::EVP_PKEY_up_ref as *const ());
+println!("{:?}", depends_mundane_v1::EVP_PKEY_assign_EC_KEY as *const ());
+println!("{:?}", depends_mundane_v1::EVP_PKEY_get1_EC_KEY as *const ());
+println!("{:?}", depends_mundane_v1::EVP_parse_public_key as *const ());
+println!("{:?}", depends_mundane_v1::EVP_marshal_public_key as *const ());
+println!("{:?}", depends_mundane_v1::PKCS5_PBKDF2_HMAC as *const ());
+println!("{:?}", depends_mundane_v1::EVP_PBE_scrypt as *const ());
+println!("{:?}", depends_mundane_v1::HMAC_CTX_init as *const ());
+println!("{:?}", depends_mundane_v1::HMAC_CTX_cleanup as *const ());
+println!("{:?}", depends_mundane_v1::HMAC_Init_ex as *const ());
+println!("{:?}", depends_mundane_v1::HMAC_Update as *const ());
+println!("{:?}", depends_mundane_v1::HMAC_Final as *const ());
+println!("{:?}", depends_mundane_v1::HMAC_size as *const ());
+println!("{:?}", depends_mundane_v1::CRYPTO_memcmp as *const ());
+println!("{:?}", depends_mundane_v1::RAND_bytes as *const ());
+println!("{:?}", depends_mundane_v1::SHA1_Init as *const ());
+println!("{:?}", depends_mundane_v1::SHA1_Update as *const ());
+println!("{:?}", depends_mundane_v1::SHA1_Final as *const ());
+println!("{:?}", depends_mundane_v1::SHA256_Init as *const ());
+println!("{:?}", depends_mundane_v1::SHA256_Update as *const ());
+println!("{:?}", depends_mundane_v1::SHA256_Final as *const ());
+println!("{:?}", depends_mundane_v1::SHA384_Init as *const ());
+println!("{:?}", depends_mundane_v1::SHA384_Update as *const ());
+println!("{:?}", depends_mundane_v1::SHA384_Final as *const ());
+println!("{:?}", depends_mundane_v1::SHA512_Init as *const ());
+println!("{:?}", depends_mundane_v1::SHA512_Update as *const ());
+println!("{:?}", depends_mundane_v1::SHA512_Final as *const ());
+println!("{:?}", depends_mundane_v2::ERR_print_errors_cb as *const ());
+println!("{:?}", depends_mundane_v2::CBS_init as *const ());
+println!("{:?}", depends_mundane_v2::CBS_len as *const ());
+println!("{:?}", depends_mundane_v2::CBB_init as *const ());
+println!("{:?}", depends_mundane_v2::CBB_cleanup as *const ());
+println!("{:?}", depends_mundane_v2::CBB_data as *const ());
+println!("{:?}", depends_mundane_v2::CBB_len as *const ());
+println!("{:?}", depends_mundane_v2::ED25519_keypair as *const ());
+println!("{:?}", depends_mundane_v2::ED25519_sign as *const ());
+println!("{:?}", depends_mundane_v2::ED25519_verify as *const ());
+println!("{:?}", depends_mundane_v2::ED25519_keypair_from_seed as *const ());
+println!("{:?}", depends_mundane_v2::EVP_sha1 as *const ());
+println!("{:?}", depends_mundane_v2::EVP_sha256 as *const ());
+println!("{:?}", depends_mundane_v2::EVP_sha384 as *const ());
+println!("{:?}", depends_mundane_v2::EVP_sha512 as *const ());
+println!("{:?}", depends_mundane_v2::EC_GROUP_new_by_curve_name as *const ());
+println!("{:?}", depends_mundane_v2::EC_GROUP_get_curve_name as *const ());
+println!("{:?}", depends_mundane_v2::EC_curve_nid2nist as *const ());
+println!("{:?}", depends_mundane_v2::EC_KEY_new as *const ());
+println!("{:?}", depends_mundane_v2::EC_KEY_free as *const ());
+println!("{:?}", depends_mundane_v2::EC_KEY_up_ref as *const ());
+println!("{:?}", depends_mundane_v2::EC_KEY_get0_group as *const ());
+println!("{:?}", depends_mundane_v2::EC_KEY_set_group as *const ());
+println!("{:?}", depends_mundane_v2::EC_KEY_generate_key as *const ());
+println!("{:?}", depends_mundane_v2::EC_KEY_parse_private_key as *const ());
+println!("{:?}", depends_mundane_v2::EC_KEY_marshal_private_key as *const ());
+println!("{:?}", depends_mundane_v2::ECDSA_sign as *const ());
+println!("{:?}", depends_mundane_v2::ECDSA_verify as *const ());
+println!("{:?}", depends_mundane_v2::ECDSA_size as *const ());
+println!("{:?}", depends_mundane_v2::EVP_PKEY_new as *const ());
+println!("{:?}", depends_mundane_v2::EVP_PKEY_free as *const ());
+println!("{:?}", depends_mundane_v2::EVP_PKEY_up_ref as *const ());
+println!("{:?}", depends_mundane_v2::EVP_PKEY_assign_EC_KEY as *const ());
+println!("{:?}", depends_mundane_v2::EVP_PKEY_get1_EC_KEY as *const ());
+println!("{:?}", depends_mundane_v2::EVP_parse_public_key as *const ());
+println!("{:?}", depends_mundane_v2::EVP_marshal_public_key as *const ());
+println!("{:?}", depends_mundane_v2::PKCS5_PBKDF2_HMAC as *const ());
+println!("{:?}", depends_mundane_v2::EVP_PBE_scrypt as *const ());
+println!("{:?}", depends_mundane_v2::HMAC_CTX_init as *const ());
+println!("{:?}", depends_mundane_v2::HMAC_CTX_cleanup as *const ());
+println!("{:?}", depends_mundane_v2::HMAC_Init_ex as *const ());
+println!("{:?}", depends_mundane_v2::HMAC_Update as *const ());
+println!("{:?}", depends_mundane_v2::HMAC_Final as *const ());
+println!("{:?}", depends_mundane_v2::HMAC_size as *const ());
+println!("{:?}", depends_mundane_v2::CRYPTO_memcmp as *const ());
+println!("{:?}", depends_mundane_v2::RAND_bytes as *const ());
+println!("{:?}", depends_mundane_v2::SHA1_Init as *const ());
+println!("{:?}", depends_mundane_v2::SHA1_Update as *const ());
+println!("{:?}", depends_mundane_v2::SHA1_Final as *const ());
+println!("{:?}", depends_mundane_v2::SHA256_Init as *const ());
+println!("{:?}", depends_mundane_v2::SHA256_Update as *const ());
+println!("{:?}", depends_mundane_v2::SHA256_Final as *const ());
+println!("{:?}", depends_mundane_v2::SHA384_Init as *const ());
+println!("{:?}", depends_mundane_v2::SHA384_Update as *const ());
+println!("{:?}", depends_mundane_v2::SHA384_Final as *const ());
+println!("{:?}", depends_mundane_v2::SHA512_Init as *const ());
+println!("{:?}", depends_mundane_v2::SHA512_Update as *const ());
+println!("{:?}", depends_mundane_v2::SHA512_Final as *const ());
+}
+EOF
+
+cargo build --release
+
+cd -
+rm -rf "$TMP"
\ No newline at end of file
diff --git a/build.rs b/build.rs
new file mode 100644
index 0000000..6662e83
--- /dev/null
+++ b/build.rs
@@ -0,0 +1,256 @@
+// Copyright 2018 Google LLC
+//
+// Use of this source code is governed by an MIT-style
+// license that can be found in the LICENSE file or at
+// https://opensource.org/licenses/MIT.
+
+// This build script is responsible for building BoringSSL with the appropriate
+// symbol prefix. See boringssl/README.md for details.
+
+use std::env;
+use std::fs;
+use std::process::{Command, Stdio};
+
+// Relative to CARGO_MANIFEST_DIR
+const BORINGSSL_SRC: &str = "boringssl/boringssl";
+
+// Relative to OUT_DIR
+const BUILD_DIR_1: &str = "boringssl/build_1";
+const BUILD_DIR_2: &str = "boringssl/build_2";
+const SYMBOL_FILE: &str = "boringssl/symbols.txt";
+
+fn env(name: &str) -> String {
+ let var = env::var(name).expect(&format!("missing required environment variable {}", name));
+ println!("cargo:rerun-if-env-changed={}", var);
+ var
+}
+
+fn main() {
+ validate_dependencies();
+
+ let manifest_dir = env("CARGO_MANIFEST_DIR");
+ let abs_boringssl_src = format!("{}/{}", manifest_dir, BORINGSSL_SRC);
+
+ let out_dir = env("OUT_DIR");
+ let abs_build_dir_1 = format!("{}/{}", out_dir, BUILD_DIR_1);
+ let abs_build_dir_2 = format!("{}/{}", out_dir, BUILD_DIR_2);
+ let abs_symbol_file = format!("{}/{}", out_dir, SYMBOL_FILE);
+
+ fs::create_dir_all(&abs_build_dir_1).expect("failed to create first build directory");
+ fs::create_dir_all(&abs_build_dir_2).expect("failed to create second build directory");
+
+ let major = env("CARGO_PKG_VERSION_MAJOR");
+ let minor = env("CARGO_PKG_VERSION_MINOR");
+ let patch = env("CARGO_PKG_VERSION_PATCH");
+ let version_string = format!("{}_{}_{}", major, minor, patch);
+ let prefix = format!("__RUST_MUNDANE_{}", version_string);
+ let cmake_version_flag = format!("-DBORINGSSL_PREFIX={}", prefix);
+
+ let built_with = built_with(&abs_build_dir_1);
+ let have_ninja = have_ninja();
+ let build = |build_dir, flags: &[&str]| {
+ fn with_ninja<'a, 'b>(flags: &'a [&'b str]) -> Vec<&'b str> {
+ let mut flags = flags.to_vec();
+ flags.push("-GNinja");
+ flags
+ }
+
+ env::set_current_dir(build_dir).expect("failed to cd to build directory");
+ // If we've already run a build, then we need to build with the same
+ // tool the second time around, or cmake will complain. There's
+ // technically a chance that, after having built, the user uninstalled
+ // the build tool, but that's unlikely enough that it's not worth
+ // introducing the complexity necessary to support that use case.
+ match built_with {
+ Some(BuildSystem::Ninja) => {
+ run("cmake", &with_ninja(flags));
+ run("ninja", &["crypto"]);
+ }
+ Some(BuildSystem::Make) => {
+ run("cmake", flags);
+ run("make", &["crypto"]);
+ }
+ None => {
+ if have_ninja {
+ run("cmake", &with_ninja(flags));
+ run("ninja", &["crypto"]);
+ } else {
+ run("cmake", flags);
+ run("make", &["crypto"]);
+ }
+ }
+ }
+ };
+
+ build(&abs_build_dir_1, &[&abs_boringssl_src]);
+
+ // 'go run' requires that we're cd'd into a subdirectory of the Go module
+ // root in order for Go modules to work
+ let orig = env::current_dir().expect("could not get current directory");
+ env::set_current_dir(&format!("{}/util", &abs_boringssl_src))
+ .expect("could not set current directory");
+ run(
+ "go",
+ &[
+ "run",
+ "read_symbols.go",
+ "-out",
+ &abs_symbol_file,
+ &format!("{}/crypto/libcrypto.a", &abs_build_dir_1),
+ ],
+ );
+ env::set_current_dir(orig).expect("could not set current directory");
+
+ build(
+ &abs_build_dir_2,
+ &[
+ &abs_boringssl_src,
+ &cmake_version_flag,
+ "-DBORINGSSL_PREFIX_SYMBOLS=../symbols.txt",
+ ],
+ );
+
+ // NOTE(joshlf): We symlink rather than renaming so that the BoringSSL build
+ // system won't notice that libcrypto.a is gone and spuriously attempt to
+ // rebuild.
+ #[cfg(unix)]
+ let res = std::os::unix::fs::symlink(
+ format!("{}/crypto/libcrypto.a", abs_build_dir_2),
+ format!("{}/crypto/libcrypto_{}.a", abs_build_dir_2, version_string),
+ );
+ #[cfg(windows)]
+ let res = std::os::windows::fs::symlink_file(
+ format!("{}/crypto/libcrypto.a", abs_build_dir_2),
+ format!("{}/crypto/libcrypto_{}.a", abs_build_dir_2, version_string),
+ );
+ // If symlinking isn't available, we fall back to renaming.
+ #[cfg(not(any(unix, windows)))]
+ let res = fs::rename(
+ format!("{}/crypto/libcrypto.a", abs_build_dir_2),
+ format!("{}/crypto/libcrypto_{}.a", abs_build_dir_2, version_string),
+ );
+
+ if let Err(err) = res {
+ // If the error is an AlreadyExists error, that just means we've already
+ // compiled before. Renaming to an existing file works without error, so
+ // it's OK that our panic message only mentions symlinking.
+ if err.kind() != std::io::ErrorKind::AlreadyExists {
+ panic!("could not symlink to libcrypto.a: {}", err)
+ }
+ }
+
+ println!("cargo:rustc-link-search=native={}/crypto", abs_build_dir_2);
+}
+
+// Validates that dependencies which we invoke directly are present, or panics
+// with an error message. Does not check for dependencies of BoringSSL's build
+// system.
+fn validate_dependencies() {
+ let go = have_go();
+ let cmake = have_cmake();
+ let ninja = have_ninja();
+ let make = have_make();
+
+ if !go {
+ panic!(
+ "
+
+Missing build dependency Go (1.11 or higher).
+
+"
+ );
+ }
+ if !cmake {
+ panic!(
+ "
+
+Missing build dependency CMake.
+
+"
+ );
+ }
+ if cfg!(windows) && !ninja {
+ panic!(
+ "
+
+Building on Windows requires the Ninja tool. See https://ninja-build.org/.
+
+"
+ );
+ }
+ if !make && !ninja {
+ panic!(
+ "
+
+Building requires either Make or Ninja (https://ninja-build.org/).
+
+"
+ );
+ }
+}
+
+// Runs a command and panic if it fails.
+fn run(cmd: &str, args: &[&str]) {
+ let output = Command::new(cmd)
+ .args(args)
+ .stdout(Stdio::inherit())
+ .stderr(Stdio::inherit())
+ .output()
+ .expect(&format!("failed to invoke {}", cmd));
+ if !output.status.success() {
+ panic!("{} failed with status {}", cmd, output.status);
+ }
+}
+
+// Is Go installed?
+fn have_go() -> bool {
+ have("go", &["version"])
+}
+
+// Is CMake installed?
+fn have_cmake() -> bool {
+ have("cmake", &["--version"])
+}
+
+// Is Ninja installed?
+fn have_ninja() -> bool {
+ have("ninja", &["--version"])
+}
+
+// Is Make installed?
+fn have_make() -> bool {
+ have("make", &["--version"])
+}
+
+// Checks whether a program is installed by running it.
+//
+// `have` checks whether `name` is installed by running it with the provided
+// `args`. It must exist successfully.
+fn have(name: &str, args: &[&str]) -> bool {
+ Command::new(name)
+ .args(args)
+ .output()
+ .map(|output| output.status.success())
+ .unwrap_or(false)
+}
+
+enum BuildSystem {
+ Ninja,
+ Make,
+}
+
+// Checks which build tool was used for the previous build.
+fn built_with(abs_dir: &str) -> Option<BuildSystem> {
+ let is_file = |file| {
+ fs::metadata(format!("{}/{}", abs_dir, file))
+ .map(|meta| meta.is_file())
+ .unwrap_or(false)
+ };
+ if is_file("build.ninja") {
+ Some(BuildSystem::Ninja)
+ } else if is_file("Makefile") {
+ Some(BuildSystem::Make)
+ } else {
+ None
+ }
+}
diff --git a/src/boringssl/abort.rs b/src/boringssl/abort.rs
new file mode 100644
index 0000000..d422c91
--- /dev/null
+++ b/src/boringssl/abort.rs
@@ -0,0 +1,200 @@
+// Copyright 2018 Google LLC
+//
+// Use of this source code is governed by an MIT-style
+// license that can be found in the LICENSE file or at
+// https://opensource.org/licenses/MIT.
+
+//! Macros and functions that abort instead of unwinding.
+//!
+//! Writing `unsafe` code which retains memory safety in the face of unwinding
+//! is [notoriously
+//! difficult](https://doc.rust-lang.org/nightly/nomicon/exception-safety.html).
+//! This module provides panic-related macros and functions that abort rather
+//! than unwind. These are used in place of unwinding-based macros and functions
+//! so that we can avoid the high probability of us getting unwind-safe code
+//! wrong.
+
+use std::fmt::Debug;
+
+macro_rules! assert_abort {
+ ($cond:expr) => ({
+ let cond = $cond;
+ let cond_str = stringify!($cond);
+ assert_abort!(cond, "{}", cond_str);
+ });
+ ($cond:expr,) => ({
+ assert_abort!($cond);
+ });
+ ($cond:expr, $msg:expr, $($arg:tt)*) => ({
+ if !($cond) {
+ panic_abort!(concat!("assertion failed: ", $msg), $($arg)*);
+ }
+ });
+}
+
+macro_rules! assert_abort_eq {
+ ($left:expr, $right:expr) => ({
+ match (&$left, &$right) {
+ (left_val, right_val) => {
+ if !(*left_val == *right_val) {
+ panic_abort!(r#"assertion failed: `(left == right)`
+ left: `{:?}`,
+ right: `{:?}`"#, left_val, right_val)
+ }
+ }
+ }
+ });
+ ($left:expr, $right:expr,) => ({
+ assert_eq!($left, $right)
+ });
+ ($left:expr, $right:expr, $($arg:tt)+) => ({
+ match (&($left), &($right)) {
+ (left_val, right_val) => {
+ if !(*left_val == *right_val) {
+ panic_abort!(r#"assertion failed: `(left == right)`
+ left: `{:?}`,
+ right: `{:?}`: {}"#, left_val, right_val,
+ format_args!($($arg)+))
+ }
+ }
+ }
+ });
+}
+
+#[allow(unused)]
+macro_rules! unimplemented_abort {
+ () => {{
+ panic_abort!("not yet implemented")
+ }};
+}
+
+macro_rules! unreachable_abort {
+ () => {{
+ panic_abort!("internal error: entered unreachable code")
+ }};
+}
+
+macro_rules! panic_abort {
+ () => ({
+ panic_abort!("explicit panic")
+ });
+ ($msg:expr) => ({
+ eprintln!("{}", $msg);
+ ::std::process::abort();
+ });
+ ($msg:expr,) => ({
+ panic_abort!($msg)
+ });
+ ($fmt:expr, $($arg:tt)+) => ({
+ panic_abort!(format!($fmt, $($arg)+));
+ });
+}
+
+// Redefine normal panic/assert macros so their use will cause a compiler error.
+
+#[allow(unused)]
+macro_rules! panic {
+ ($($x:tt)*) => {
+ compile_error!("use panic_abort! instead of panic! in boringssl module")
+ };
+}
+
+#[allow(unused)]
+macro_rules! assert {
+ ($($x:tt)*) => {
+ compile_error!("use assert_abort! instead of assert! in boringssl module")
+ };
+}
+
+#[allow(unused)]
+macro_rules! assert_eq {
+ ($($x:tt)*) => {
+ compile_error!("use assert_abort_eq! instead of assert_eq! in boringssl module")
+ };
+}
+
+#[allow(unused)]
+macro_rules! assert_ne {
+ ($($x:tt)*) => {
+ compile_error!("use assert_abort_ne! instead of assert_ne! in boringssl module")
+ };
+}
+
+#[allow(unused)]
+macro_rules! unimplemented {
+ ($($x:tt)*) => {
+ compile_error!("use unimplemented_abort! instead of unimplemented! in boringssl module")
+ };
+}
+
+#[allow(unused)]
+macro_rules! unreachable {
+ ($($x:tt)*) => {
+ compile_error!("use unreachable_abort! instead of unreachable! in boringssl module")
+ };
+}
+
+// unwrap and expect
+
+// TODO(joshlf): Is there a way (maybe with clippy) that we can cause warnings
+// or errors if this module ever uses unwrap or expect?
+
+pub trait UnwrapAbort {
+ type Item;
+
+ fn unwrap_abort(self) -> Self::Item;
+ fn expect_abort(self, msg: &str) -> Self::Item;
+}
+
+// The implementations for Option and Result are adapted from the Rust standard library.
+impl<T> UnwrapAbort for Option<T> {
+ type Item = T;
+
+ fn unwrap_abort(self) -> T {
+ match self {
+ Some(val) => val,
+ None => panic_abort!("called `Option::unwrap_abort()` on a `None` value"),
+ }
+ }
+
+ fn expect_abort(self, msg: &str) -> T {
+ // This is a separate function to reduce the code size of alloc_expect itself
+ #[inline(never)]
+ #[cold]
+ fn failed(msg: &str) -> ! {
+ panic_abort!("{}", msg);
+ }
+
+ match self {
+ Some(val) => val,
+ None => failed(msg),
+ }
+ }
+}
+
+impl<T, E: Debug> UnwrapAbort for Result<T, E> {
+ type Item = T;
+
+ fn unwrap_abort(self) -> T {
+ match self {
+ Ok(val) => val,
+ Err(err) => {
+ result_unwrap_failed("called `Result::unwrap_abort()` on an `Err` value", err)
+ }
+ }
+ }
+
+ fn expect_abort(self, msg: &str) -> T {
+ match self {
+ Ok(val) => val,
+ Err(err) => result_unwrap_failed(msg, err),
+ }
+ }
+}
+
+// This is a separate function to reduce the code size of alloc_{expect,unwrap}
+#[inline(never)]
+#[cold]
+fn result_unwrap_failed<E: Debug>(msg: &str, err: E) -> ! {
+ panic_abort!("{}: {:?}", msg, err)
+}
diff --git a/src/boringssl/mod.rs b/src/boringssl/mod.rs
new file mode 100644
index 0000000..2327577
--- /dev/null
+++ b/src/boringssl/mod.rs
@@ -0,0 +1,743 @@
+// Copyright 2018 Google LLC
+//
+// Use of this source code is governed by an MIT-style
+// license that can be found in the LICENSE file or at
+// https://opensource.org/licenses/MIT.
+
+//! The BoringSSL API.
+//!
+//! This module provides a safe access to the BoringSSL API.
+//!
+//! It accomplishes this using the following structure:
+//! - The internal `raw` module provides nearly-raw access to the BoringSSL API.
+//! For each function in the BoringSSL API, it exposes an equivalent Rust
+//! function which performs error checking. Functions which return pointers
+//! return `Result<NonNull<T>, BoringError>`, functions which return status
+//! codes return `Result<(), BoringError>`, etc. This API makes it less likely
+//! to accidentally forget to check for null pointers or error status codes.
+//! - The internal `wrapper` module provides types which wrap C objects and
+//! handle many of the details of their lifecycles. These include
+//! `CStackWrapper`, which handles initializing and destructing
+//! stack-allocated C objects; `CHeapWrapper`, which is analogous to Rust's
+//! `Box` or `Rc`, and handles allocation, reference counting, and freeing;
+//! and `CRef`, which is analogous to a Rust reference.
+//! - This module builds on top of the `raw` and `wrapper` modules to provide a
+//! safe API. This allows us to `#![forbid(unsafe_code)]` in the rest of the
+//! crate, which in turn means that this is the only module whose memory
+//! safety needs to be manually verified.
+//!
+//! # Usage
+//!
+//! Each type, `T`, from the BoringSSL API is exposed as either a
+//! `CStackWrapper<T>`, a `CHeapWrapper<T>`, or a `CRef<T>`. Each function from
+//! the BoringSSL API which operates on a particular type is exposed as a method
+//! on the wrapped version of that type. For example, the BoringSSL `CBS_len`
+//! function operates on a `CBS`; we provide the `cbs_len` method on the
+//! `CStackWrapper<CBS>` type. While BoringSSL functions that operate on a
+//! particular type take the form `TYPE_method`, the Rust equivalents are all
+//! lower-case - `type_method`.
+//!
+//! Some functions which do not make sense as methods are exposed as bare
+//! functions. For example, the BoringSSL `ECDSA_sign` function is exposed as a
+//! bare function as `ecdsa_sign`.
+//!
+//! Types which can be constructed without arguments implement `Default`. Types
+//! which require arguments to be constructed provide associated functions which
+//! take those arguments and return a new instance of that type. For example,
+//! the `CHeapWrapper<EC_KEY>::ec_key_parse_private_key` function parses a
+//! private key from an input stream and returns a new `CHeapWrapper<EC_KEY>`.
+//!
+//! # API Guidelines
+//!
+//! This module is meant to be as close as possible to a direct set of FFI
+//! bindings while still providing a safe API. While memory safety is handled
+//! internally, and certain error conditions which could affect memory safety
+//! are checked internally (and cause the process to abort if they fail), most
+//! errors are returned from the API, as they are considered business logic,
+//! which is outside the scope of this module.
+
+// NOTES on safety requirements of the BoringSSL API:
+// - Though it may not be explicitly documented, calling methods on uinitialized
+// values is UB. Remember, this is C! Always initialize (usually via XXX_init
+// or a similarly-named function) before calling any methods or functions.
+// - Any BoringSSL documentation that says "x property must hold" means that, if
+// that property doesn't hold, it may cause UB - you are not guaranteed that
+// it will be detected and an error will be returned.
+
+// NOTE(joshlf): It's important to define this module before the abort module,
+// or else all of the assertions that are auto-generated by bindgen would result
+// in compilation errors.
+#[path = "../../boringssl/boringssl.rs"]
+mod ffi;
+#[macro_use]
+mod abort;
+#[macro_use]
+mod wrapper;
+mod raw;
+
+// C types
+pub use boringssl::ffi::{CBB, CBS, EC_GROUP, EC_KEY, EVP_MD, EVP_PKEY, HMAC_CTX, SHA256_CTX,
+ SHA512_CTX, SHA_CTX};
+// C constants
+pub use boringssl::ffi::{NID_X9_62_prime256v1, NID_secp384r1, NID_secp521r1,
+ ED25519_PRIVATE_KEY_LEN, ED25519_PUBLIC_KEY_LEN, ED25519_SIGNATURE_LEN,
+ SHA256_DIGEST_LENGTH, SHA384_DIGEST_LENGTH, SHA512_DIGEST_LENGTH,
+ SHA_DIGEST_LENGTH};
+// wrapper types
+pub use boringssl::wrapper::{CHeapWrapper, CRef, CStackWrapper};
+
+use std::ffi::CStr;
+use std::fmt::{self, Debug, Display, Formatter};
+use std::num::NonZeroUsize;
+use std::os::raw::{c_char, c_int, c_uint, c_void};
+use std::{mem, ptr, slice};
+
+use boringssl::abort::UnwrapAbort;
+use boringssl::raw::{CBB_data, CBB_init, CBB_len, CBS_init, CBS_len, CRYPTO_memcmp, ECDSA_sign,
+ ECDSA_size, ECDSA_verify, EC_GROUP_get_curve_name,
+ EC_GROUP_new_by_curve_name, EC_KEY_generate_key, EC_KEY_get0_group,
+ EC_KEY_marshal_private_key, EC_KEY_parse_private_key, EC_KEY_set_group,
+ EC_curve_nid2nist, ED25519_keypair, ED25519_keypair_from_seed, ED25519_sign,
+ ED25519_verify, ERR_print_errors_cb, EVP_PBE_scrypt, EVP_PKEY_assign_EC_KEY,
+ EVP_PKEY_get1_EC_KEY, EVP_marshal_public_key, EVP_parse_public_key,
+ HMAC_CTX_init, HMAC_Final, HMAC_Init_ex, HMAC_Update, HMAC_size, RAND_bytes,
+ SHA384_Init};
+
+impl CStackWrapper<CBB> {
+ /// Creates a new `CBB` and initializes it with `CBB_init`.
+ ///
+ /// `cbb_new` can only fail due to OOM.
+ #[must_use]
+ pub fn cbb_new(initial_capacity: usize) -> Result<CStackWrapper<CBB>, BoringError> {
+ unsafe {
+ let mut cbb = mem::uninitialized();
+ CBB_init(&mut cbb, initial_capacity)?;
+ Ok(CStackWrapper::new(cbb))
+ }
+ }
+
+ /// Invokes a callback on the contents of a `CBB`.
+ ///
+ /// `cbb_with_data` accepts a callback, and invokes that callback, passing a
+ /// slice of the current contents of this `CBB`.
+ #[must_use]
+ pub fn cbb_with_data<O, F: Fn(&[u8]) -> O>(&self, with_data: F) -> O {
+ unsafe {
+ // NOTE: The return value of CBB_data is only valid until the next
+ // operation on the CBB. This method is safe because the slice
+ // reference cannot outlive this function body, and thus cannot live
+ // beyond another method call that could invalidate the buffer.
+ let len = CBB_len(self.as_const());
+ if len == 0 {
+ // If len is 0, then CBB_data could technically return a null
+ // pointer. Constructing a slice from a null pointer is likely
+ // invalid, so we do this instead.
+ with_data(&[])
+ } else {
+ // Since the length is non-zero, CBB_data should not return a
+ // null pointer.
+ let ptr = CBB_data(self.as_const()).unwrap_abort();
+ // TODO(joshlf): Can with_data use this to smuggle out the
+ // reference, outliving the lifetime of self?
+ with_data(slice::from_raw_parts(ptr.as_ptr(), len))
+ }
+ }
+ }
+}
+
+impl CStackWrapper<CBS> {
+ /// The `CBS_len` function.
+ #[must_use]
+ pub fn cbs_len(&self) -> usize {
+ unsafe { CBS_len(self.as_const()) }
+ }
+
+ /// Invokes a callback on a temporary `CBS`.
+ ///
+ /// `cbs_with_temp_buffer` constructs a `CBS` from the provided byte slice,
+ /// and invokes a callback on the `CBS`. The `CBS` is destructed before
+ /// `cbs_with_temp_buffer` returns.
+ // TODO(joshlf): Holdover until we figure out how to put lifetimes in CStackWrappers.
+ #[must_use]
+ pub fn cbs_with_temp_buffer<O, F: Fn(&mut CStackWrapper<CBS>) -> O>(
+ bytes: &[u8], with_cbs: F,
+ ) -> O {
+ unsafe {
+ let mut cbs = mem::uninitialized();
+ CBS_init(&mut cbs, bytes.as_ptr(), bytes.len());
+ let mut cbs = CStackWrapper::new(cbs);
+ with_cbs(&mut cbs)
+ }
+ }
+}
+
+impl CRef<'static, EC_GROUP> {
+ /// The `EC_GROUP_new_by_curve_name` function.
+ #[must_use]
+ pub fn ec_group_new_by_curve_name(nid: c_int) -> Result<CRef<'static, EC_GROUP>, BoringError> {
+ unsafe { Ok(CRef::new(EC_GROUP_new_by_curve_name(nid)?)) }
+ }
+}
+
+impl<'a> CRef<'a, EC_GROUP> {
+ /// The `EC_GROUP_get_curve_name` function.
+ #[must_use]
+ pub fn ec_group_get_curve_name(&self) -> c_int {
+ unsafe { EC_GROUP_get_curve_name(self.as_const()) }
+ }
+}
+
+/// The `EC_curve_nid2nist` function.
+#[must_use]
+pub fn ec_curve_nid2nist(nid: c_int) -> Result<&'static CStr, BoringError> {
+ unsafe { Ok(CStr::from_ptr(EC_curve_nid2nist(nid)?.as_ptr())) }
+}
+
+impl CHeapWrapper<EC_KEY> {
+ /// The `EC_KEY_generate_key` function.
+ #[must_use]
+ pub fn ec_key_generate_key(&mut self) -> Result<(), BoringError> {
+ unsafe { EC_KEY_generate_key(self.as_mut()) }
+ }
+
+ /// The `EC_KEY_parse_private_key` function.
+ ///
+ /// If `group` is `None`, then the group pointer argument to
+ /// `EC_KEY_parse_private_key` will be NULL.
+ #[must_use]
+ pub fn ec_key_parse_private_key(
+ cbs: &mut CStackWrapper<CBS>, group: Option<CRef<'static, EC_GROUP>>,
+ ) -> Result<CHeapWrapper<EC_KEY>, BoringError> {
+ unsafe {
+ Ok(CHeapWrapper::new_from(EC_KEY_parse_private_key(
+ cbs.as_mut(),
+ group.map(|g| g.as_const()).unwrap_or(ptr::null()),
+ )?))
+ }
+ }
+
+ /// The `EC_KEY_get0_group` function.
+ #[must_use]
+ #[allow(clippy::needless_lifetimes)] // to be more explicit
+ pub fn ec_key_get0_group<'a>(&'a self) -> Result<CRef<'a, EC_GROUP>, BoringError> {
+ // get0 doesn't increment the refcount; the lifetimes ensure that the
+ // returned CRef can't outlive self
+ unsafe { Ok(CRef::new(EC_KEY_get0_group(self.as_const())?)) }
+ }
+
+ /// The `EC_KEY_set_group` function.
+ #[must_use]
+ pub fn ec_key_set_group(&mut self, group: &CRef<'static, EC_GROUP>) -> Result<(), BoringError> {
+ unsafe { EC_KEY_set_group(self.as_mut(), group.as_const()) }
+ }
+
+ /// The `EC_KEY_marshal_private_key` function.
+ #[must_use]
+ pub fn ec_key_marshal_private_key(
+ &self, cbb: &mut CStackWrapper<CBB>,
+ ) -> Result<(), BoringError> {
+ unsafe { EC_KEY_marshal_private_key(cbb.as_mut(), self.as_const(), 0) }
+ }
+}
+
+/// The `ECDSA_sign` function.
+///
+/// `ecdsa_sign` returns the number of bytes written to `sig`.
+///
+/// # Panics
+///
+/// `ecdsa_sign` panics if `sig` is shorter than the minimum required signature
+/// size given by `ecdsa_size`, or if `key` doesn't have a group set.
+#[must_use]
+pub fn ecdsa_sign(
+ digest: &[u8], sig: &mut [u8], key: &CHeapWrapper<EC_KEY>,
+) -> Result<usize, BoringError> {
+ unsafe {
+ // If we call ECDSA_sign with sig.len() < min_size, it will invoke UB.
+ // ECDSA_size fails if the key doesn't have a group set.
+ let min_size = ecdsa_size(key).unwrap_abort();
+ assert_abort!(sig.len() >= min_size.get());
+
+ let mut sig_len: c_uint = 0;
+ ECDSA_sign(
+ 0,
+ digest.as_ptr(),
+ digest.len(),
+ sig.as_mut_ptr(),
+ &mut sig_len,
+ key.as_const(),
+ )?;
+ // ECDSA_sign guarantees that it only needs ECDSA_size bytes for the
+ // signature.
+ assert_abort!(sig_len as usize <= min_size.get());
+ Ok(sig_len as usize)
+ }
+}
+
+/// The `ECDSA_verify` function.
+#[must_use]
+pub fn ecdsa_verify(digest: &[u8], sig: &[u8], key: &CHeapWrapper<EC_KEY>) -> bool {
+ unsafe {
+ ECDSA_verify(
+ 0,
+ digest.as_ptr(),
+ digest.len(),
+ sig.as_ptr(),
+ sig.len(),
+ key.as_const(),
+ )
+ }
+}
+
+/// The `ECDSA_size` function.
+#[must_use]
+pub fn ecdsa_size(key: &CHeapWrapper<EC_KEY>) -> Result<NonZeroUsize, BoringError> {
+ unsafe { ECDSA_size(key.as_const()) }
+}
+
+/// The `ED25519_keypair` function.
+#[must_use]
+pub fn ed25519_keypair() -> [u8; ED25519_PRIVATE_KEY_LEN as usize] {
+ let mut public_unused = [0u8; ED25519_PUBLIC_KEY_LEN as usize];
+ let mut private = [0u8; ED25519_PRIVATE_KEY_LEN as usize];
+ unsafe {
+ ED25519_keypair(
+ (&mut public_unused[..]).as_mut_ptr(),
+ (&mut private[..]).as_mut_ptr(),
+ )
+ };
+ private
+}
+
+/// The `ED25519_sign` function.
+#[must_use]
+pub fn ed25519_sign(message: &[u8], private_key: &[u8; 64]) -> Result<[u8; 64], BoringError> {
+ let mut sig = [0u8; 64];
+ unsafe { ED25519_sign(&mut sig, message.as_ptr(), message.len(), private_key)? };
+ Ok(sig)
+}
+
+/// The `ED25519_keypair_from_seed` function.
+#[must_use]
+pub fn ed25519_keypair_from_seed(seed: &[u8; 32]) -> ([u8; 32], [u8; 64]) {
+ let mut public = [0u8; 32];
+ let mut private = [0u8; 64];
+ unsafe {
+ ED25519_keypair_from_seed(
+ (&mut public[..]).as_mut_ptr(),
+ (&mut private[..]).as_mut_ptr(),
+ (&seed[..]).as_ptr(),
+ )
+ };
+ (public, private)
+}
+
+/// The `ED25519_verify` function.
+#[must_use]
+pub fn ed25519_verify(message: &[u8], signature: &[u8; 64], public_key: &[u8; 32]) -> bool {
+ unsafe { ED25519_verify(message.as_ptr(), message.len(), signature, public_key) }
+}
+
+impl CHeapWrapper<EVP_PKEY> {
+ /// The `EVP_parse_public_key` function.
+ #[must_use]
+ pub fn evp_parse_public_key(
+ cbs: &mut CStackWrapper<CBS>,
+ ) -> Result<CHeapWrapper<EVP_PKEY>, BoringError> {
+ unsafe { Ok(CHeapWrapper::new_from(EVP_parse_public_key(cbs.as_mut())?)) }
+ }
+
+ /// The `EVP_marshal_public_key` function.
+ #[must_use]
+ pub fn evp_marshal_public_key(&self, cbb: &mut CStackWrapper<CBB>) -> Result<(), BoringError> {
+ unsafe { EVP_marshal_public_key(cbb.as_mut(), self.as_const()) }
+ }
+
+ /// The `EVP_PKEY_assign_EC_KEY` function.
+ #[must_use]
+ pub fn evp_pkey_assign_ec_key(&mut self, ec_key: CHeapWrapper<EC_KEY>) {
+ unsafe {
+ // NOTE: It's very important that we use 'into_mut' here so that
+ // ec_key's refcount is not decremented. That's because
+ // EVP_PKEY_assign_EC_KEY doesn't increment the refcount of its
+ // argument.
+ let key = ec_key.into_mut();
+ // EVP_PKEY_assign_EC_KEY only fails if key is NULL.
+ EVP_PKEY_assign_EC_KEY(self.as_mut(), key).unwrap_abort()
+ }
+ }
+
+ /// The `EVP_PKEY_get1_EC_KEY` function.
+ #[must_use]
+ pub fn evp_pkey_get1_ec_key(&mut self) -> Result<CHeapWrapper<EC_KEY>, BoringError> {
+ // NOTE: It's important that we use get1 here, as it increments the
+ // refcount of the EC_KEY before returning a pointer to it.
+ unsafe { Ok(CHeapWrapper::new_from(EVP_PKEY_get1_EC_KEY(self.as_mut())?)) }
+ }
+}
+
+/// The `EVP_PBE_scrypt` function.
+#[allow(non_snake_case)]
+#[must_use]
+pub fn evp_pbe_scrypt(
+ password: &[u8], salt: &[u8], N: u64, r: u64, p: u64, max_mem: usize, out_key: &mut [u8],
+) -> Result<(), BoringError> {
+ unsafe {
+ EVP_PBE_scrypt(
+ password.as_ptr() as *const c_char,
+ password.len(),
+ salt.as_ptr(),
+ salt.len(),
+ N,
+ r,
+ p,
+ max_mem,
+ out_key.as_mut_ptr(),
+ out_key.len(),
+ )
+ }
+}
+
+/// The `PKCS5_PBKDF2_HMAC` function.
+#[cfg(feature = "kdf")]
+#[must_use]
+pub fn pkcs5_pbkdf2_hmac(
+ password: &[u8], salt: &[u8], iterations: c_uint, digest: &CRef<'static, EVP_MD>,
+ out_key: &mut [u8],
+) -> Result<(), BoringError> {
+ unsafe {
+ raw::PKCS5_PBKDF2_HMAC(
+ password.as_ptr() as *const c_char,
+ password.len(),
+ salt.as_ptr(),
+ salt.len(),
+ iterations,
+ digest.as_const(),
+ out_key.len(),
+ out_key.as_mut_ptr(),
+ )
+ }
+}
+
+impl CStackWrapper<SHA512_CTX> {
+ /// Initializes a new `CStackWrapper<SHA512_CTX>` as a SHA-384 hash.
+ ///
+ /// The BoringSSL `SHA512_CTX` is used for both the SHA-512 and SHA-384 hash
+ /// functions. The implementation of `Default` for
+ /// `CStackWrapper<SHA512_CTX>` produces a context initialized for a SHA-512
+ /// hash. In order to produce a context for a SHA-384 hash, use this
+ /// constructor instead.
+ #[must_use]
+ pub fn sha384_new() -> CStackWrapper<SHA512_CTX> {
+ unsafe {
+ let mut ctx = mem::uninitialized();
+ SHA384_Init(&mut ctx);
+ CStackWrapper::new(ctx)
+ }
+ }
+}
+
+macro_rules! impl_evp_digest {
+ (#[$doc:meta] $name:ident, $raw_name:ident) => {
+ #[$doc]
+ #[must_use]
+ pub fn $name() -> CRef<'static, EVP_MD> {
+ unsafe { CRef::new(::boringssl::raw::$raw_name()) }
+ }
+ };
+}
+
+impl CRef<'static, EVP_MD> {
+ impl_evp_digest!(
+ /// The `EVP_sha1` function.
+ evp_sha1,
+ EVP_sha1
+ );
+ impl_evp_digest!(
+ /// The `EVP_sha256` function.
+ evp_sha256,
+ EVP_sha256
+ );
+ impl_evp_digest!(
+ /// The `EVP_sha384` function.
+ evp_sha384,
+ EVP_sha384
+ );
+ impl_evp_digest!(
+ /// The `EVP_sha512` function.
+ evp_sha512,
+ EVP_sha512
+ );
+}
+
+impl CStackWrapper<HMAC_CTX> {
+ /// Initializes a new `HMAC_CTX`.
+ ///
+ /// `hmac_ctx_new` initializes a new `HMAC_CTX` using `HMAC_CTX_init` and
+ /// then further initializes it with `HMAC_CTX_Init_ex`. It can only fail
+ /// due to OOM.
+ #[must_use]
+ pub fn hmac_ctx_new(
+ key: &[u8], md: &CRef<'static, EVP_MD>,
+ ) -> Result<CStackWrapper<HMAC_CTX>, BoringError> {
+ unsafe {
+ let mut ctx = mem::uninitialized();
+ HMAC_CTX_init(&mut ctx);
+ HMAC_Init_ex(
+ &mut ctx,
+ key.as_ptr() as *const c_void,
+ key.len(),
+ md.as_const(),
+ )?;
+ Ok(CStackWrapper::new(ctx))
+ }
+ }
+
+ /// The `HMAC_Update` function.
+ #[must_use]
+ pub fn hmac_update(&mut self, data: &[u8]) {
+ unsafe { HMAC_Update(self.as_mut(), data.as_ptr(), data.len()) }
+ }
+
+ // NOTE(joshlf): We require exactly the right length (as opposed to just
+ // long enough) so that we don't have to have hmac_final return a length.
+
+ /// The `HMAC_Final` function.
+ ///
+ /// # Panics
+ ///
+ /// `hmac_final` panics if `out` is not exactly the right length (as defined
+ /// by `HMAC_size`).
+ #[must_use]
+ pub fn hmac_final(&mut self, out: &mut [u8]) {
+ unsafe {
+ let size = HMAC_size(self.as_const());
+ assert_abort_eq!(out.len(), size);
+ let mut size = 0;
+ // HMAC_Final is documented to fail on allocation failure, but an
+ // internal comment states that it's infallible. In either case, we
+ // want to panic. Normally, for allocation failure, we'd put the
+ // unwrap higher in the stack, but since this is supposed to be
+ // infallible anyway, we put it here.
+ //
+ // TODO(joshlf): Remove this comment once HMAC_Final is documented
+ // as being infallible.
+ HMAC_Final(self.as_mut(), out.as_mut_ptr(), &mut size).unwrap_abort();
+ // Guaranteed to be the value returned by HMAC_size.
+ assert_abort_eq!(out.len(), size as usize);
+ }
+ }
+}
+
+/// Implements `CStackWrapper` for a hash context type.
+///
+/// The caller provides doc comments, a public method name, and a private
+/// function name (from the `raw` module) for an update function and a final
+/// function (e.g., `SHA256_Update` and `SHA256_Final`). Note that, as multiple
+/// impl blocks are allowed for a particular type, the same context type may be
+/// used multiple times. This is useful because both SHA-384 and SHA-512 use the
+/// `SHA512_CTX` context type.
+macro_rules! impl_hash {
+ ($ctx:ident, $digest_len:ident, #[$update_doc:meta] $update:ident, $update_raw:ident, #[$final_doc:meta] $final:ident, $final_raw:ident) => {
+ impl CStackWrapper<$ctx> {
+ #[$update_doc]
+ pub fn $update(&mut self, data: &[u8]) {
+ unsafe {
+ ::boringssl::raw::$update_raw(
+ self.as_mut(),
+ data.as_ptr() as *const c_void,
+ data.len(),
+ )
+ }
+ }
+
+ #[$final_doc]
+ #[must_use]
+ pub fn $final(
+ &mut self,
+ ) -> [u8; ::boringssl::ffi::$digest_len as usize] {
+ unsafe {
+ let mut md: [u8; ::boringssl::ffi::$digest_len as usize] = mem::uninitialized();
+ // SHA1_Final promises to return 1. SHA256_Final,
+ // SHA384_Final, and SHA512_Final all document that they
+ // only fail due to programmer error. The only input to the
+ // function which could cause this is the context. I suspect
+ // that the error condition is that XXX_Final is called
+ // twice without resetting, but I'm not sure. Until we
+ // figure it out, let's err on the side of caution and abort
+ // here.
+ //
+ // TODO(joshlf): Figure out how XXX_Final can fail.
+ ::boringssl::raw::$final_raw((&mut md[..]).as_mut_ptr(), self.as_mut()).unwrap_abort();
+ md
+ }
+ }
+ }
+ };
+ (@doc_string $s:expr) => (#[doc="The `"] #[doc=$s] #[doc="` function."]);
+}
+
+impl_hash!(
+ SHA_CTX,
+ SHA_DIGEST_LENGTH,
+ /// The `SHA1_Update` function.
+ sha1_update,
+ SHA1_Update,
+ /// The `SHA1_Final` function.
+ sha1_final,
+ SHA1_Final
+);
+impl_hash!(
+ SHA256_CTX,
+ SHA256_DIGEST_LENGTH,
+ /// The `SHA256_Update` function.
+ sha256_update,
+ SHA256_Update,
+ /// The `SHA256_Final` function.
+ sha256_final,
+ SHA256_Final
+);
+impl_hash!(
+ SHA512_CTX,
+ SHA384_DIGEST_LENGTH,
+ /// The `SHA384_Update` function.
+ sha384_update,
+ SHA384_Update,
+ /// The `SHA384_Final` function.
+ sha384_final,
+ SHA384_Final
+);
+impl_hash!(
+ SHA512_CTX,
+ SHA512_DIGEST_LENGTH,
+ /// The `SHA512_Update` function.
+ sha512_update,
+ SHA512_Update,
+ /// The `SHA512_Final` function.
+ sha512_final,
+ SHA512_Final
+);
+
+/// The `CRYPTO_memcmp` function.
+///
+/// `crypto_memcmp` first verifies that `a.len() == b.len()` before calling
+/// `CRYPTO_memcmp`.
+#[must_use]
+pub fn crypto_memcmp(a: &[u8], b: &[u8]) -> bool {
+ if a.len() != b.len() {
+ return false;
+ }
+ unsafe {
+ CRYPTO_memcmp(
+ a.as_ptr() as *const c_void,
+ b.as_ptr() as *const c_void,
+ a.len(),
+ ) == 0
+ }
+}
+
+/// The `RAND_bytes` function.
+pub fn rand_bytes(buf: &mut [u8]) {
+ unsafe { RAND_bytes(buf.as_mut_ptr(), buf.len()) }
+}
+
+/// An error generated by BoringSSL.
+///
+/// The `Debug` impl prints a stack trace. Each element of the trace corresponds
+/// to a function within BoringSSL which voluntarily pushed itself onto the
+/// stack. In this sense, it is not the same as a normal stack trace. Each
+/// element of the trace is of the form `[thread id]:error:[error code]:[library
+/// name]:OPENSSL_internal:[reason string]:[file]:[line number]:[optional string
+/// data]`.
+///
+/// The `Display` impl prints the first element of the stack trace.
+///
+/// Some BoringSSL functions do not record any error in the error stack. Errors
+/// generated from such functions are printed as `error calling <function name>`
+/// for both `Debug` and `Display` impls.
+pub struct BoringError {
+ stack_trace: Vec<String>,
+}
+
+impl BoringError {
+ /// Consumes the error stack.
+ ///
+ /// `f` is the name of the function that failed. If the error stack is empty
+ /// (some BoringSSL functions do not push errors onto the stack when
+ /// returning errors), the returned `BoringError` will simply note that the
+ /// named function failed; both the `Debug` and `Display` implementations
+ /// will return `error calling f`, where `f` is the value of the `f`
+ /// argument.
+ #[must_use]
+ fn consume_stack(f: &str) -> BoringError {
+ let stack_trace = {
+ let trace = get_error_stack_trace();
+ if trace.is_empty() {
+ vec![format!("error calling {}", f)]
+ } else {
+ trace
+ }
+ };
+ BoringError { stack_trace }
+ }
+
+ /// The number of frames in the stack trace.
+ ///
+ /// Guaranteed to be at least 1.
+ #[must_use]
+ pub fn stack_depth(&self) -> usize {
+ self.stack_trace.len()
+ }
+}
+
+fn get_error_stack_trace() -> Vec<String> {
+ // Credit to agl@google.com for this implementation.
+
+ unsafe extern "C" fn error_callback(s: *const c_char, s_len: usize, ctx: *mut c_void) -> c_int {
+ let stack_trace = ctx as *mut Vec<String>;
+ let s = ::std::slice::from_raw_parts(s as *const u8, s_len - 1);
+ (*stack_trace).push(String::from_utf8_lossy(s).to_string());
+ 1
+ }
+
+ let mut stack_trace = Vec::new();
+ unsafe {
+ ERR_print_errors_cb(
+ Some(error_callback),
+ &mut stack_trace as *mut _ as *mut c_void,
+ )
+ };
+ stack_trace
+}
+
+impl Display for BoringError {
+ fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> {
+ write!(f, "{}", self.stack_trace[0])
+ }
+}
+
+impl Debug for BoringError {
+ fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> {
+ for elem in &self.stack_trace {
+ writeln!(f, "{}", elem)?;
+ }
+ Ok(())
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use util::should_fail;
+
+ #[test]
+ fn test_boring_error() {
+ CStackWrapper::cbs_with_temp_buffer(&[], |cbs| {
+ should_fail(
+ CHeapWrapper::evp_parse_public_key(cbs),
+ "boringssl::EVP_parse_public_key",
+ "public key routines:OPENSSL_internal:DECODE_ERROR",
+ );
+ });
+ }
+}
diff --git a/src/boringssl/raw.rs b/src/boringssl/raw.rs
new file mode 100644
index 0000000..76ea6db
--- /dev/null
+++ b/src/boringssl/raw.rs
@@ -0,0 +1,401 @@
+// Copyright 2018 Google LLC
+//
+// Use of this source code is governed by an MIT-style
+// license that can be found in the LICENSE file or at
+// https://opensource.org/licenses/MIT.
+
+//! Almost-raw bindings to the BoringSSL API.
+//!
+//! The `raw` module provides bindings to the BoringSSL API which add a little
+//! bit of safety beyond the safety provided by completely raw bindings by
+//! ensuring that all return values are checked for errors, and converting these
+//! C-style return values into Rust `Result`s.
+//!
+//! This module also directly re-exports any raw bindings which are infallible
+//! (e.g., `void` functions).
+
+// infallible functions
+pub use boringssl::ffi::{CBB_cleanup, CBB_len, CBS_init, CBS_len, CRYPTO_memcmp,
+ EC_GROUP_get_curve_name, ED25519_keypair, ED25519_keypair_from_seed,
+ ERR_print_errors_cb, HMAC_CTX_init, HMAC_size};
+
+use std::num::NonZeroUsize;
+use std::os::raw::{c_char, c_int, c_uint, c_void};
+use std::ptr::{self, NonNull};
+
+use boringssl::ffi::{self, CBB, CBS, EC_GROUP, EC_KEY, EVP_MD, EVP_PKEY, HMAC_CTX, SHA512_CTX};
+
+use boringssl::wrapper::CInit;
+use boringssl::BoringError;
+
+// bytestring.h
+
+impl_traits!(CBB, CDestruct => CBB_cleanup);
+impl_traits!(CBS, CDestruct => _);
+
+#[allow(non_snake_case)]
+#[must_use]
+pub unsafe fn CBB_init(cbb: *mut CBB, initial_capacity: usize) -> Result<(), BoringError> {
+ one_or_err("CBB_init", ffi::CBB_init(cbb, initial_capacity))
+}
+
+#[allow(non_snake_case)]
+#[must_use]
+pub unsafe fn CBB_data(cbb: *const CBB) -> Result<NonNull<u8>, BoringError> {
+ ptr_or_err("CBB_init", ffi::CBB_data(cbb) as *mut _)
+}
+
+// curve25519.h
+
+#[allow(non_snake_case)]
+#[must_use]
+pub unsafe fn ED25519_sign(
+ out: *mut [u8; 64], message: *const u8, message_len: usize, private_key: *const [u8; 64],
+) -> Result<(), BoringError> {
+ one_or_err(
+ "ED25519_sign",
+ ffi::ED25519_sign(
+ out as *mut u8,
+ message,
+ message_len,
+ private_key as *const u8,
+ ),
+ )
+}
+
+#[allow(non_snake_case)]
+#[must_use]
+pub unsafe fn ED25519_verify(
+ message: *const u8, message_len: usize, signature: *const [u8; 64], public_key: *const [u8; 32],
+) -> bool {
+ match ffi::ED25519_verify(
+ message,
+ message_len,
+ signature as *const u8,
+ public_key as *const u8,
+ ) {
+ 0 => false,
+ 1 => true,
+ // ED25519_verify promises to only return 0 or 1
+ _ => unreachable_abort!(),
+ }
+}
+
+// digest.h
+
+macro_rules! evp_digest {
+ ($name:ident) => {
+ #[allow(non_snake_case)]
+ #[must_use]
+ pub unsafe fn $name() -> NonNull<EVP_MD> {
+ // These return pointers to statically-allocated objects, so should
+ // never fail.
+ use boringssl::abort::UnwrapAbort;
+ ptr_or_err(stringify!($name), ffi::$name() as *mut _).unwrap_abort()
+ }
+ };
+}
+
+evp_digest!(EVP_sha1);
+evp_digest!(EVP_sha256);
+evp_digest!(EVP_sha384);
+evp_digest!(EVP_sha512);
+
+// ec.h
+
+#[allow(non_snake_case)]
+#[must_use]
+pub unsafe fn EC_GROUP_new_by_curve_name(nid: c_int) -> Result<NonNull<EC_GROUP>, BoringError> {
+ ptr_or_err(
+ "EC_GROUP_new_by_curve_name",
+ ffi::EC_GROUP_new_by_curve_name(nid),
+ )
+}
+
+// ec_key.h
+
+impl_traits!(EC_KEY, CNew => EC_KEY_new, CUpRef => EC_KEY_up_ref, CFree => EC_KEY_free);
+impl_traits!(EVP_PKEY, CNew => EVP_PKEY_new, CUpRef => EVP_PKEY_up_ref, CFree => EVP_PKEY_free);
+
+#[allow(non_snake_case)]
+#[must_use]
+pub unsafe fn EC_curve_nid2nist(nid: c_int) -> Result<NonNull<c_char>, BoringError> {
+ ptr_or_err("EC_curve_nid2nist", ffi::EC_curve_nid2nist(nid) as *mut _)
+}
+
+#[allow(non_snake_case)]
+#[must_use]
+pub unsafe fn EC_KEY_generate_key(key: *mut EC_KEY) -> Result<(), BoringError> {
+ one_or_err("EC_KEY_generate_key", ffi::EC_KEY_generate_key(key))
+}
+
+#[allow(non_snake_case)]
+#[must_use]
+pub unsafe fn EC_KEY_get0_group(key: *const EC_KEY) -> Result<NonNull<EC_GROUP>, BoringError> {
+ ptr_or_err("EC_KEY_get0_group", ffi::EC_KEY_get0_group(key) as *mut _)
+}
+
+#[allow(non_snake_case)]
+#[must_use]
+pub unsafe fn EC_KEY_marshal_private_key(
+ cbb: *mut CBB, key: *const EC_KEY, enc_flags: c_uint,
+) -> Result<(), BoringError> {
+ one_or_err(
+ "EC_KEY_marshal_private_key",
+ ffi::EC_KEY_marshal_private_key(cbb, key, enc_flags),
+ )
+}
+
+#[allow(non_snake_case)]
+#[must_use]
+pub unsafe fn EC_KEY_parse_private_key(
+ cbs: *mut CBS, group: *const EC_GROUP,
+) -> Result<NonNull<EC_KEY>, BoringError> {
+ ptr_or_err(
+ "EC_KEY_parse_private_key",
+ ffi::EC_KEY_parse_private_key(cbs, group),
+ )
+}
+
+#[allow(non_snake_case)]
+#[must_use]
+pub unsafe fn EC_KEY_set_group(
+ key: *mut EC_KEY, group: *const EC_GROUP,
+) -> Result<(), BoringError> {
+ one_or_err("EC_KEY_set_group", ffi::EC_KEY_set_group(key, group))
+}
+
+// ecdsa.h
+
+#[allow(non_snake_case)]
+#[must_use]
+pub unsafe fn ECDSA_sign(
+ type_: c_int, digest: *const u8, digest_len: usize, sig: *mut u8, sig_len: *mut c_uint,
+ key: *const EC_KEY,
+) -> Result<(), BoringError> {
+ one_or_err(
+ "ECDSA_sign",
+ ffi::ECDSA_sign(type_, digest, digest_len, sig, sig_len, key),
+ )
+}
+
+#[allow(non_snake_case)]
+#[must_use]
+pub unsafe fn ECDSA_size(key: *const EC_KEY) -> Result<NonZeroUsize, BoringError> {
+ NonZeroUsize::new(ffi::ECDSA_size(key)).ok_or_else(|| BoringError::consume_stack("ECDSA_size"))
+}
+
+#[allow(non_snake_case)]
+#[must_use]
+pub unsafe fn ECDSA_verify(
+ type_: c_int, digest: *const u8, digest_len: usize, sig: *const u8, sig_len: usize,
+ key: *const EC_KEY,
+) -> bool {
+ match ffi::ECDSA_verify(type_, digest, digest_len, sig, sig_len, key) {
+ 1 => true,
+ 0 => false,
+ // ECDSA_verify promises to only return 0 or 1
+ _ => unreachable_abort!(),
+ }
+}
+
+// evp.h
+
+#[allow(non_snake_case)]
+#[must_use]
+pub unsafe fn EVP_marshal_public_key(
+ cbb: *mut CBB, key: *const EVP_PKEY,
+) -> Result<(), BoringError> {
+ one_or_err(
+ "EVP_marshal_public_key",
+ ffi::EVP_marshal_public_key(cbb, key),
+ )
+}
+
+#[allow(non_snake_case)]
+#[must_use]
+pub unsafe fn EVP_parse_public_key(cbs: *mut CBS) -> Result<NonNull<EVP_PKEY>, BoringError> {
+ ptr_or_err("EVP_parse_public_key", ffi::EVP_parse_public_key(cbs))
+}
+
+#[allow(non_snake_case)]
+#[must_use]
+pub unsafe fn EVP_PKEY_assign_EC_KEY(
+ pkey: *mut EVP_PKEY, key: *mut EC_KEY,
+) -> Result<(), BoringError> {
+ one_or_err(
+ "EVP_PKEY_assign_EC_KEY",
+ ffi::EVP_PKEY_assign_EC_KEY(pkey, key),
+ )
+}
+
+#[allow(non_snake_case)]
+#[must_use]
+pub unsafe fn EVP_PKEY_get1_EC_KEY(pkey: *mut EVP_PKEY) -> Result<NonNull<EC_KEY>, BoringError> {
+ ptr_or_err("EVP_PKEY_get1_EC_KEY", ffi::EVP_PKEY_get1_EC_KEY(pkey))
+}
+
+#[allow(non_snake_case)]
+#[allow(clippy::too_many_arguments)]
+#[must_use]
+pub unsafe fn EVP_PBE_scrypt(
+ password: *const c_char, password_len: usize, salt: *const u8, salt_len: usize, N: u64, r: u64,
+ p: u64, max_mem: usize, out_key: *mut u8, key_len: usize,
+) -> Result<(), BoringError> {
+ one_or_err(
+ "EVP_PBE_scrypt",
+ ffi::EVP_PBE_scrypt(
+ password,
+ password_len,
+ salt,
+ salt_len,
+ N,
+ r,
+ p,
+ max_mem,
+ out_key,
+ key_len,
+ ),
+ )
+}
+
+#[cfg(feature = "kdf")]
+#[allow(non_snake_case)]
+#[allow(clippy::too_many_arguments)]
+#[must_use]
+pub unsafe fn PKCS5_PBKDF2_HMAC(
+ password: *const c_char, password_len: usize, salt: *const u8, salt_len: usize,
+ iterations: c_uint, digest: *const EVP_MD, key_len: usize, out_key: *mut u8,
+) -> Result<(), BoringError> {
+ one_or_err(
+ "PKCS5_PBKDF2_HMAC",
+ ffi::PKCS5_PBKDF2_HMAC(
+ password,
+ password_len,
+ salt,
+ salt_len,
+ iterations,
+ digest,
+ key_len,
+ out_key,
+ ),
+ )
+}
+
+// hmac.h
+
+// NOTE: We don't implement CInit because some functions that take an HMAC_CTX
+// pointer have extra invariants beyond simply having called HMAC_CTX_init. If
+// we implemented CInit, then safe code would be able to construct a
+// CStackWrapper<HMAC_CTX> using Default::default, and then pass a pointer to
+// that object to functions that require extra initialization, leading to
+// usoundness.
+impl_traits!(HMAC_CTX, CDestruct => HMAC_CTX_cleanup);
+
+#[allow(non_snake_case)]
+#[must_use]
+pub unsafe fn HMAC_Init_ex(
+ ctx: *mut HMAC_CTX, key: *const c_void, key_len: usize, md: *const EVP_MD,
+) -> Result<(), BoringError> {
+ one_or_err(
+ "HMAC_Init_ex",
+ ffi::HMAC_Init_ex(ctx, key, key_len, md, ptr::null_mut()),
+ )
+}
+
+#[allow(non_snake_case)]
+#[must_use]
+pub unsafe fn HMAC_Update(ctx: *mut HMAC_CTX, data: *const u8, data_len: usize) {
+ // HMAC_Update promises to return 1.
+ assert_abort_eq!(ffi::HMAC_Update(ctx, data, data_len), 1);
+}
+
+#[allow(non_snake_case)]
+#[must_use]
+pub unsafe fn HMAC_Final(
+ ctx: *mut HMAC_CTX, out: *mut u8, out_len: *mut c_uint,
+) -> Result<(), BoringError> {
+ one_or_err("HMAC_Final", ffi::HMAC_Final(ctx, out, out_len))
+}
+
+// rand.h
+
+#[allow(non_snake_case)]
+#[must_use]
+pub unsafe fn RAND_bytes(buf: *mut u8, len: usize) {
+ // RAND_bytes promises to return 1.
+ assert_abort_eq!(ffi::RAND_bytes(buf, len), 1);
+}
+
+// sha.h
+
+#[allow(non_snake_case)]
+#[must_use]
+pub unsafe fn SHA384_Init(ctx: *mut SHA512_CTX) {
+ // SHA384_Init promises to return 1.
+ assert_abort_eq!(ffi::SHA384_Init(ctx), 1);
+}
+
+// Implemented manually (rather than via impl_traits! or c_init!) so that we can
+// assert_abort_eq! that the return value is 1.
+unsafe impl CInit for ffi::SHA_CTX {
+ unsafe fn init(ctx: *mut Self) {
+ // SHA1_Init promises to return 1.
+ assert_abort_eq!(ffi::SHA1_Init(ctx), 1);
+ }
+}
+unsafe impl CInit for ffi::SHA256_CTX {
+ unsafe fn init(ctx: *mut Self) {
+ // SHA256_Init promises to return 1.
+ assert_abort_eq!(ffi::SHA256_Init(ctx), 1);
+ }
+}
+unsafe impl CInit for ffi::SHA512_CTX {
+ unsafe fn init(ctx: *mut Self) {
+ // SHA512_Init promises to return 1.
+ assert_abort_eq!(ffi::SHA512_Init(ctx), 1);
+ }
+}
+
+// implement no-op destructors
+impl_traits!(SHA_CTX, CDestruct => _);
+impl_traits!(SHA256_CTX, CDestruct => _);
+impl_traits!(SHA512_CTX, CDestruct => _);
+
+macro_rules! sha {
+ ($ctx:ident, $update:ident, $final:ident) => {
+ #[allow(non_snake_case)]
+ pub unsafe fn $update(ctx: *mut ffi::$ctx, data: *const c_void, len: usize) {
+ // All XXX_Update functions promise to return 1.
+ assert_abort_eq!(ffi::$update(ctx, data, len), 1);
+ }
+ #[allow(non_snake_case)]
+ pub unsafe fn $final(md: *mut u8, ctx: *mut ffi::$ctx) -> Result<(), BoringError> {
+ one_or_err(stringify!($final), ffi::$final(md, ctx))
+ }
+ };
+}
+
+sha!(SHA_CTX, SHA1_Update, SHA1_Final);
+sha!(SHA256_CTX, SHA256_Update, SHA256_Final);
+sha!(SHA512_CTX, SHA384_Update, SHA384_Final);
+sha!(SHA512_CTX, SHA512_Update, SHA512_Final);
+
+// utility functions
+
+// If code is 1, returns Ok, otherwise returns Err. f should be the name of the
+// function that returned this value.
+#[must_use]
+pub fn one_or_err(f: &str, code: c_int) -> Result<(), BoringError> {
+ if code == 1 {
+ Ok(())
+ } else {
+ Err(BoringError::consume_stack(f))
+ }
+}
+
+// If ptr is non-NULL, returns Ok, otherwise returns Err. f should be the name
+// of the function that returned this value.
+fn ptr_or_err<T>(f: &str, ptr: *mut T) -> Result<NonNull<T>, BoringError> {
+ NonNull::new(ptr).ok_or_else(|| BoringError::consume_stack(f))
+}
diff --git a/src/boringssl/wrapper.rs b/src/boringssl/wrapper.rs
new file mode 100644
index 0000000..2c63130
--- /dev/null
+++ b/src/boringssl/wrapper.rs
@@ -0,0 +1,370 @@
+// Copyright 2018 Google LLC
+//
+// Use of this source code is governed by an MIT-style
+// license that can be found in the LICENSE file or at
+// https://opensource.org/licenses/MIT.
+
+use std::marker::PhantomData;
+use std::mem;
+use std::ptr::NonNull;
+
+/// A trait that can be used to ensure that users of the boringssl module can't
+/// implement a trait.
+///
+/// See the [API Guidelines] for details.
+///
+/// [API Guidelines]: https://rust-lang-nursery.github.io/api-guidelines/future-proofing.html#sealed-traits-protect-against-downstream-implementations-c-sealed
+pub trait Sealed {}
+
+macro_rules! sealed {
+ ($name:ident) => {
+ impl ::boringssl::wrapper::Sealed for ::boringssl::raw::ffi::$name {}
+ };
+}
+
+macro_rules! impl_traits {
+ (@inner $name:ident, CNew => $fn:tt) => {
+ c_new!($name, $fn);
+ };
+ (@inner $name:ident, CUpRef => $fn:tt) => {
+ c_up_ref!($name, $fn);
+ };
+ (@inner $name:ident, CFree => $fn:tt) => {
+ c_free!($name, $fn);
+ };
+ (@inner $name:ident, CInit => $fn:tt) => {
+ c_init!($name, $fn);
+ };
+ (@inner $name:ident, CDestruct => $fn:tt) => {
+ c_destruct!($name, $fn);
+ };
+ (@inner $name:ident, $trait:ident => $fn:tt) => {
+ compile_error!(concat!("unrecognized trait ", stringify!($trait)));
+ };
+ ($name:ident, $($trait:ident => $fn:tt),*) => {
+ sealed!($name);
+ $(impl_traits!(@inner $name, $trait => $fn);)*
+ };
+}
+
+/// A C object from the BoringSSL API which can be allocated and constructed.
+pub unsafe trait CNew: Sealed {
+ /// Returns a new, constructed, heap-allocated object, or NULL on failure.
+ ///
+ /// This should not be called directly; instead, use `new`.
+ #[deprecated = "do not call new_raw directly; instead, call new"]
+ unsafe fn new_raw() -> *mut Self;
+
+ /// Returns a new, constructed, heap-allocated object, or `None` on failure.
+ #[must_use]
+ unsafe fn new() -> Option<NonNull<Self>> {
+ #[allow(deprecated)]
+ NonNull::new(Self::new_raw())
+ }
+}
+
+macro_rules! c_new {
+ ($name:ident, $new:ident) => {
+ unsafe impl ::boringssl::wrapper::CNew for ::boringssl::raw::ffi::$name {
+ unsafe fn new_raw() -> *mut Self {
+ ::boringssl::raw::ffi::$new()
+ }
+ }
+ };
+}
+
+/// A C object from the BoringSSL API which has a reference count that can be
+/// increased.
+pub unsafe trait CUpRef: Sealed {
+ /// Increases an object's reference count.
+ unsafe fn up_ref(slf: *mut Self);
+}
+
+macro_rules! c_up_ref {
+ ($name:ident, $up_ref:ident) => {
+ unsafe impl ::boringssl::wrapper::CUpRef for ::boringssl::raw::ffi::$name {
+ unsafe fn up_ref(slf: *mut Self) {
+ use boringssl::abort::UnwrapAbort;
+ ::boringssl::raw::one_or_err(
+ stringify!($up_ref),
+ ::boringssl::raw::ffi::$up_ref(slf),
+ ).unwrap_abort()
+ }
+ }
+ };
+}
+
+/// A C object from the BoringSSL API which can be freed.
+pub unsafe trait CFree: Sealed {
+ /// Frees a heap-allocated object.
+ ///
+ /// If this is a reference-counted object, `free` decrements the reference
+ /// count, and frees the object if it reaches zero. Otherwise, if this is
+ /// not a reference-counted object, it frees it.
+ unsafe fn free(slf: *mut Self);
+}
+
+macro_rules! c_free {
+ ($name:ident, $free:ident) => {
+ unsafe impl ::boringssl::wrapper::CFree for ::boringssl::raw::ffi::$name {
+ unsafe fn free(slf: *mut Self) {
+ ::boringssl::raw::ffi::$free(slf)
+ }
+ }
+ };
+}
+
+/// A C object from the BoringSSL API which can be initialized.
+pub unsafe trait CInit: Sealed {
+ /// Initializes an uninitialized object.
+ ///
+ /// # Safety
+ ///
+ /// `init` must not be called on an initialized object.
+ unsafe fn init(slf: *mut Self);
+}
+
+#[allow(unused)] // TODO: Remove once it's used in the 'raw' module
+macro_rules! c_init {
+ ($name:ident, $init:ident) => {
+ unsafe impl ::boringssl::wrapper::CInit for ::boringssl::raw::ffi::$name {
+ unsafe fn init(slf: *mut Self) {
+ ::boringssl::raw::ffi::$init(slf)
+ }
+ }
+ };
+}
+
+/// A C object from the BoringSSL API which can be destructed.
+pub unsafe trait CDestruct: Sealed {
+ /// Destructs an initialized object.
+ ///
+ /// # Safety
+ ///
+ /// `slf` must be an initialized object. After a call to `destruct`, `slf`
+ /// is uninitialized.
+ unsafe fn destruct(slf: *mut Self);
+}
+
+macro_rules! c_destruct {
+ ($name:ident, _) => {
+ unsafe impl ::boringssl::wrapper::CDestruct for ::boringssl::raw::ffi::$name {
+ unsafe fn destruct(_slf: *mut Self) {}
+ }
+ };
+ ($name:ident, $destruct:tt) => {
+ unsafe impl ::boringssl::wrapper::CDestruct for ::boringssl::raw::ffi::$name {
+ unsafe fn destruct(slf: *mut Self) {
+ ::boringssl::raw::ffi::$destruct(slf)
+ }
+ }
+ };
+}
+
+/// A wrapper around a pointer to a heap-allocated, constructed C object from
+/// the BoringSSL API.
+///
+/// `CHeapWrapper` maintains the invariant that the object it references is
+/// always allocated and constructed. This means that:
+/// - If the object can be reference counted, `CHeapWrapper` implements `Clone`
+/// by incrementing the reference count, and decrementing on `Drop`.
+/// - If the object cannot be reference counted, `CHeapWrapper` does not
+/// implement `Clone`, but will still free the object on `Drop`.
+///
+/// `CHeapWrapper`s are not thread-safe; they do not implement `Send` or `Sync`.
+pub struct CHeapWrapper<C: CFree> {
+ // NOTE: NonNull ensures that CHeapWrapper is !Send + !Sync. If this struct
+ // is changed, make sure it's still !Send + !Sync.
+ obj: NonNull<C>,
+}
+
+impl<C: CFree> CHeapWrapper<C> {
+ /// Takes ownership of a constructed object.
+ ///
+ /// # Safety
+ ///
+ /// `obj` must point to an allocated, constructed object. The caller must
+ /// ensure that, when the returned `CHeapWrapper` is dropped, it is safe to
+ /// call `C::free` on `obj`. In most cases, this means that the caller
+ /// should not free `obj`, and instead consider ownership of `obj` to have
+ /// transferred to the new `CHeapWrapper`.
+ ///
+ /// The caller must also ensure that no pointers to the object will ever be
+ /// used by other threads so long as this `CHeapWrapper` exists.
+ #[must_use]
+ pub unsafe fn new_from(obj: NonNull<C>) -> CHeapWrapper<C> {
+ CHeapWrapper { obj }
+ }
+
+ #[must_use]
+ pub fn as_mut(&mut self) -> *mut C {
+ self.obj.as_ptr()
+ }
+
+ #[must_use]
+ pub fn as_const(&self) -> *const C {
+ self.obj.as_ptr()
+ }
+
+ /// Consumes this `CHeapWrapper` and return the underlying pointer.
+ ///
+ /// The object will not be freed. Instead, the caller takes logical
+ /// ownership of the object.
+ #[must_use]
+ pub fn into_mut(self) -> *mut C {
+ // NOTE: This method safe for the same reason that mem::forget is safe:
+ // it's equivalent to sending it to a thread that goes to sleep forever
+ // or creating a Rc cycle or some other silly-but-safe behavior.
+ let ptr = self.obj.as_ptr();
+ mem::forget(self);
+ ptr
+ }
+}
+
+impl<C: CNew + CFree> Default for CHeapWrapper<C> {
+ fn default() -> CHeapWrapper<C> {
+ // TODO(joshlf): In order for this to be safe, CNew must provide the
+ // safety guarantee that it's always safe to call CNew::new and then
+ // later to call CFree::free on that object (e.g., see the safety
+ // comment on CStackWrapper::new).
+ unsafe {
+ use boringssl::abort::UnwrapAbort;
+ let obj = C::new().expect_abort("could not allocate object");
+ CHeapWrapper { obj }
+ }
+ }
+}
+
+impl<C: CUpRef + CFree> Clone for CHeapWrapper<C> {
+ fn clone(&self) -> CHeapWrapper<C> {
+ unsafe { C::up_ref(self.obj.as_ptr()) };
+ CHeapWrapper { obj: self.obj }
+ }
+}
+
+impl<C: CFree> Drop for CHeapWrapper<C> {
+ fn drop(&mut self) {
+ unsafe { C::free(self.obj.as_ptr()) };
+ }
+}
+
+/// A wrapper around a pointer to a C object from the BoringSSL API.
+///
+/// Unlike `CHeapWrapper` or `CStackWrapper`, `CRef` does not own the pointed-to
+/// object, but merely borrows it like a normal Rust reference. The only reason
+/// to use `CRef<C>` instead of a `&C` is to make it so that access to the `C`
+/// is unsafe, as `CRef` only exposes a raw pointer accessor for its object.
+///
+/// `CRef` maintains the invariant that the object it references is always
+/// allocated and constructed, and that mutable access to the object is disabled
+/// for the lifetime of the `CRef`.
+pub struct CRef<'a, C> {
+ // NOTE: NonNull ensures that CHeapWrapper is !Send + !Sync. If this struct
+ // is changed, make sure it's still !Send + !Sync.
+ obj: NonNull<C>,
+ // Make sure CRef has the lifetime 'a.
+ _lifetime: PhantomData<&'a ()>,
+}
+
+impl<'a, C> CRef<'a, C> {
+ /// Creates a new `CRef` from a raw pointer.
+ ///
+ /// # Safety
+ ///
+ /// `obj` must point to an allocated, constructed object. The caller must
+ /// ensure that, for the lifetime, `'a`, `obj` will continue to point to the
+ /// same allocated, constructed object, and that mutable access to the
+ /// object will be disallowed.
+ ///
+ /// The caller must also ensure that no other pointers to the object will
+ /// ever be sent to other threads so long as this `CRef` exists.
+ #[must_use]
+ pub unsafe fn new(obj: NonNull<C>) -> CRef<'a, C> {
+ CRef {
+ obj,
+ _lifetime: PhantomData,
+ }
+ }
+
+ #[must_use]
+ pub fn as_const(&self) -> *const C {
+ self.obj.as_ptr()
+ }
+}
+
+/// A wrapper around a constructed C object from the BoringSSL API.
+///
+/// `CStackWrapper` maintains the invariant that the object it contains is
+/// always constructed. The object is destructed on `Drop`.
+///
+/// `CStackWrapper`s are not thread-safe; they do not implement `Send` or
+/// `Sync`.
+pub struct CStackWrapper<C: CDestruct> {
+ obj: C,
+ // Make sure CStackWrapper doesn't implement Send or Sync regardless of C.
+ _no_sync: PhantomData<*mut ()>,
+}
+
+impl<C: CDestruct> CStackWrapper<C> {
+ /// Constructs a new `CStackWrapper`.
+ ///
+ /// # Safety
+ ///
+ /// `obj` must be constructed, and it must be safe for `C::destruct` to be
+ /// called on `obj` when this `CStackWrapper` is dropped.
+ #[must_use]
+ pub unsafe fn new(obj: C) -> CStackWrapper<C> {
+ CStackWrapper {
+ obj,
+ _no_sync: PhantomData,
+ }
+ }
+
+ #[must_use]
+ pub fn as_mut(&mut self) -> *mut C {
+ &mut self.obj
+ }
+
+ #[must_use]
+ pub fn as_const(&self) -> *const C {
+ &self.obj
+ }
+}
+
+impl<C: CInit + CDestruct> Default for CStackWrapper<C> {
+ // TODO(joshlf): In order for this to be safe, CInit must provide the safety
+ // guarantee that it's always safe to call CInit::init and then later to
+ // call CDestruct::destruct on that object (e.g., see the safety comment on
+ // CStackWrapper::new).
+ fn default() -> CStackWrapper<C> {
+ unsafe {
+ let mut obj: C = mem::uninitialized();
+ C::init(&mut obj);
+ CStackWrapper {
+ obj,
+ _no_sync: PhantomData,
+ }
+ }
+ }
+}
+
+impl<C: CDestruct> Drop for CStackWrapper<C> {
+ fn drop(&mut self) {
+ unsafe { C::destruct(&mut self.obj) }
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use boringssl::EC_KEY;
+
+ #[test]
+ fn test_heap_wrapper_into_mut() {
+ // Test that CHeapWrapper::into_mut doesn't free the pointer. If it
+ // does, then EC_KEY::free is likely (though not guaranteed) to abort
+ // when it finds the refcount at 0.
+ let key = CHeapWrapper::<EC_KEY>::default();
+ unsafe { EC_KEY::free(key.into_mut()) };
+ }
+}
diff --git a/src/hash.rs b/src/hash.rs
new file mode 100644
index 0000000..39ecef6
--- /dev/null
+++ b/src/hash.rs
@@ -0,0 +1,4389 @@
+// Copyright 2018 Google LLC
+//
+// Use of this source code is governed by an MIT-style
+// license that can be found in the LICENSE file or at
+// https://opensource.org/licenses/MIT.
+
+//! Cryptographic hash functions.
+
+use std::fmt::{self, Debug, Display, Formatter};
+
+use boringssl::{self, CStackWrapper};
+
+pub(crate) mod inner {
+ use boringssl::{CRef, EVP_MD};
+
+ pub trait Hasher {
+ fn evp_md() -> CRef<'static, EVP_MD>;
+ }
+
+ pub trait Digest {
+ /// Returns a digest of all zeroes.
+ ///
+ /// This is not exposed to the user since the all-zeroes digest is only
+ /// useful in implementing this crate (namely, being able to create a
+ /// digest to use as an out buffer), and isn't actually a meaningful
+ /// digest in the sense of being the output of a hash function.
+ fn zero() -> Self;
+
+ /// Returns a reference to the bytes of the digest.
+ ///
+ /// We do this instead of AsRef<[u8]> because the latter would expose
+ /// the as_ref method to the user.
+ ///
+ /// NOTE: This method is only used by signature implementations, and
+ /// should be removed once const generics enable the Digest::bytes
+ /// method to return `[u8; Self::DIGEST_LEN]` rather than an opaque
+ /// associated type.
+ fn as_ref(&self) -> &[u8];
+
+ /// Returns a mutable reference to the bytes of the digest.
+ ///
+ /// We do this instead of AsMut<[u8]> because the latter would expose
+ /// the as_mut method to the user.
+ fn as_mut(&mut self) -> &mut [u8];
+ }
+}
+
+/// A cryptographic hash function.
+#[must_use]
+pub trait Hasher: Default + self::inner::Hasher {
+ /// The output digest.
+ #[must_use]
+ type Digest: Digest;
+
+ /// Adds bytes to the hash.
+ fn update(&mut self, bytes: &[u8]);
+
+ /// Returns the digest of the bytes added so far.
+ #[must_use]
+ fn finish(self) -> Self::Digest;
+
+ /// Computes the hash of a sequence of bytes.
+ ///
+ /// `hash` creates a new instance of this hash function, adds `bytes` to it,
+ /// and then computes the digest.
+ #[must_use]
+ fn hash(bytes: &[u8]) -> Self::Digest {
+ let mut h = Self::default();
+ h.update(bytes);
+ h.finish()
+ }
+}
+
+/// The output of a `Hash`.
+#[must_use]
+pub trait Digest: Eq + PartialEq + Display + Debug + Sized + self::inner::Digest {
+ /// The length in bytes of this digest.
+ const DIGEST_LEN: usize;
+
+ /// The byte array equivalent of this digest.
+ ///
+ /// `Bytes` is guaranteed to be `[u8; DIGEST_LEN]`. Once const generics are
+ /// supported, this type will be removed and replaced with `[u8;
+ /// DIGEST_LEN]`.
+ type Bytes;
+
+ /// Constructs a new digest from bytes.
+ #[must_use]
+ fn from_bytes(bytes: Self::Bytes) -> Self;
+
+ /// Returns the bytes of this digest.
+ #[must_use]
+ fn bytes(&self) -> Self::Bytes;
+}
+
+// NOTE: InsecureSha1 is not publicly available; it is only used in HMAC-SHA1.
+#[cfg(feature = "insecure")]
+#[deprecated(note = "SHA-1 is considered insecure")]
+#[derive(Default)]
+pub(crate) struct InsecureSha1 {
+ ctx: CStackWrapper<boringssl::SHA_CTX>,
+}
+
+#[cfg(feature = "insecure")]
+pub(crate) mod insecure_sha1_digest {
+ use boringssl;
+
+ /// INSECURE: The digest output by the SHA-1 hash function.
+ ///
+ /// # Security
+ ///
+ /// SHA-1 is considered insecure, and should only be used for compatibility
+ /// with legacy applications.
+ #[deprecated(note = "SHA-1 is considered insecure")]
+ pub struct InsecureSha1Digest(pub(crate) [u8; boringssl::SHA_DIGEST_LENGTH as usize]);
+}
+
+/// The SHA-256 hash function.
+#[derive(Default)]
+#[must_use]
+pub struct Sha256 {
+ ctx: CStackWrapper<boringssl::SHA256_CTX>,
+}
+
+impl_debug!(Sha256, "Sha256");
+
+/// The digest output by the SHA-256 hash function.
+#[must_use]
+pub struct Sha256Digest(pub(crate) [u8; boringssl::SHA256_DIGEST_LENGTH as usize]);
+
+/// The SHA-384 hash function.
+#[must_use]
+pub struct Sha384 {
+ ctx: CStackWrapper<boringssl::SHA512_CTX>,
+}
+
+impl_debug!(Sha384, "Sha384");
+
+impl Default for Sha384 {
+ fn default() -> Sha384 {
+ // The Default impl for CStackWrapper<boringssl::SHA512_CTX> initializes
+ // it for a SHA-512 hash. Thus, we have to implement Default manually
+ // instead of deriving Default on Sha384.
+ Sha384 {
+ ctx: CStackWrapper::sha384_new(),
+ }
+ }
+}
+
+/// The digest output by the SHA-384 hash function.
+#[must_use]
+pub struct Sha384Digest(pub(crate) [u8; boringssl::SHA384_DIGEST_LENGTH as usize]);
+
+/// The SHA-512 hash function.
+#[derive(Default)]
+#[must_use]
+pub struct Sha512 {
+ ctx: CStackWrapper<boringssl::SHA512_CTX>,
+}
+
+impl_debug!(Sha512, "Sha512");
+
+/// The digest output by the SHA-512 hash function.
+#[must_use]
+pub struct Sha512Digest(pub(crate) [u8; boringssl::SHA512_DIGEST_LENGTH as usize]);
+
+/// Implements the `Hash` and `Digest` traits.
+///
+/// The caller provides the name of the hash type and the name and byte length
+/// of the digest type. The caller also provides the names of methods on the
+/// hash type's `ctx` field to update and finalize the hash. These correspond
+/// to, e.g., the BoringSSL `SHA256_Update` and `SHA256_Final` functions.
+/// Finally, the caller provides the name of the `CRef` constructor to construct
+/// a `CRef<'static, EVP_MD>` for this hash type.
+///
+/// For the digest type, the traits `PartialEq`, `Eq`, `Display`, and `Debug`
+/// are also implemented.
+macro_rules! impl_hash {
+ ($name:ident, $digest_name:path, $digest_len:path, $update:ident, $final:ident, $evp_md:ident) => {
+ #[allow(deprecated)]
+ impl ::util::Sealed for $name {}
+ #[allow(deprecated)]
+ impl Hasher for $name {
+ type Digest = $digest_name;
+ fn update(&mut self, bytes: &[u8]) {
+ #[allow(deprecated)]
+ self.ctx.$update(bytes);
+ }
+ fn finish(mut self) -> Self::Digest {
+ #[allow(deprecated)]
+ $digest_name(self.ctx.$final())
+ }
+ }
+ #[allow(deprecated)]
+ impl self::inner::Hasher for $name {
+ fn evp_md() -> ::boringssl::CRef<'static, ::boringssl::EVP_MD> {
+ ::boringssl::CRef::$evp_md()
+ }
+ }
+ #[allow(deprecated)]
+ impl self::inner::Digest for $digest_name {
+ fn zero() -> Self {
+ $digest_name([0; $digest_len as usize])
+ }
+ fn as_ref(&self) -> &[u8] {
+ &self.0[..]
+ }
+ fn as_mut(&mut self) -> &mut [u8] {
+ &mut self.0[..]
+ }
+ }
+ #[allow(deprecated)]
+ impl Digest for $digest_name {
+ const DIGEST_LEN: usize = $digest_len as usize;
+ type Bytes = [u8; $digest_len as usize];
+
+ fn from_bytes(bytes: Self::Bytes) -> Self {
+ $digest_name(bytes)
+ }
+ fn bytes(&self) -> Self::Bytes {
+ self.0
+ }
+ }
+ #[allow(deprecated)]
+ impl PartialEq for $digest_name {
+ fn eq(&self, other: &Self) -> bool {
+ boringssl::crypto_memcmp(&self.0, &other.0)
+ }
+ }
+ #[allow(deprecated)]
+ impl Eq for $digest_name {}
+ #[allow(deprecated)]
+ impl Display for $digest_name {
+ fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> {
+ for byte in &self.0[..] {
+ write!(f, "{:x}", byte)?;
+ }
+ Ok(())
+ }
+ }
+ #[allow(deprecated)]
+ impl Debug for $digest_name {
+ fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> {
+ Display::fmt(self, f)
+ }
+ }
+ };
+}
+
+#[cfg(feature = "insecure")]
+impl_hash!(
+ InsecureSha1,
+ self::insecure_sha1_digest::InsecureSha1Digest,
+ boringssl::SHA_DIGEST_LENGTH,
+ sha1_update,
+ sha1_final,
+ evp_sha1
+);
+impl_hash!(
+ Sha256,
+ Sha256Digest,
+ boringssl::SHA256_DIGEST_LENGTH,
+ sha256_update,
+ sha256_final,
+ evp_sha256
+);
+impl_hash!(
+ Sha384,
+ Sha384Digest,
+ boringssl::SHA384_DIGEST_LENGTH,
+ sha384_update,
+ sha384_final,
+ evp_sha384
+);
+impl_hash!(
+ Sha512,
+ Sha512Digest,
+ boringssl::SHA512_DIGEST_LENGTH,
+ sha512_update,
+ sha512_final,
+ evp_sha512
+);
+
+#[cfg(test)]
+mod tests {
+ #[cfg(feature = "insecure")]
+ use super::insecure_sha1_digest::*;
+ use super::*;
+
+ #[test]
+ fn test_constants() {
+ assert_eq!(<Sha256 as Hasher>::Digest::DIGEST_LEN, 32);
+ assert_eq!(<Sha384 as Hasher>::Digest::DIGEST_LEN, 48);
+ assert_eq!(<Sha512 as Hasher>::Digest::DIGEST_LEN, 64);
+
+ assert_eq!(<Sha256 as Hasher>::Digest::DIGEST_LEN, 32);
+ assert_eq!(<Sha384 as Hasher>::Digest::DIGEST_LEN, 48);
+ assert_eq!(<Sha512 as Hasher>::Digest::DIGEST_LEN, 64);
+
+ #[cfg(feature = "insecure")]
+ {
+ #[allow(deprecated)]
+ let len = <InsecureSha1 as Hasher>::Digest::DIGEST_LEN;
+ assert_eq!(len, 20);
+
+ #[allow(deprecated)]
+ let len = InsecureSha1Digest::DIGEST_LEN;
+ assert_eq!(len, 20);
+ }
+ }
+
+ #[test]
+ fn test_hash() {
+ struct TestCase {
+ input: &'static [u8],
+ #[cfg(feature = "insecure")]
+ #[allow(deprecated)]
+ sha1: <InsecureSha1 as Hasher>::Digest,
+ sha256: <Sha256 as Hasher>::Digest,
+ sha384: <Sha384 as Hasher>::Digest,
+ sha512: <Sha512 as Hasher>::Digest,
+ }
+
+ for case in TEST_CASES.iter() {
+ fn test<H: Hasher>(input: &'static [u8], digest: &H::Digest) {
+ let got = H::hash(input);
+ assert_eq!(&got, digest, "input: {:?}", input);
+ // Also use this as an opportunity to test Digest::from_bytes
+ // and Digest::as_ref.
+ assert_eq!(
+ H::Digest::from_bytes(got.bytes()),
+ H::Digest::from_bytes(digest.bytes()),
+ "input: {:?}",
+ input
+ );
+ // Test that adding bytes incrementally works too.
+ let mut hash = H::default();
+ for b in input {
+ hash.update(&[*b]);
+ }
+ assert_eq!(&hash.finish(), digest, "input: {:?}", input);
+ }
+ #[cfg(feature = "insecure")]
+ #[allow(deprecated)]
+ test::<InsecureSha1>(case.input, &case.sha1);
+ test::<Sha256>(case.input, &case.sha256);
+ test::<Sha384>(case.input, &case.sha384);
+ test::<Sha512>(case.input, &case.sha512);
+ }
+
+ macro_rules! test_case {
+ ($input:expr, $sha1:expr, $sha256:expr, $sha384:expr, $sha512:expr) => {
+ #[allow(deprecated)]
+ TestCase {
+ input: &$input,
+ #[cfg(feature = "insecure")]
+ sha1: InsecureSha1Digest($sha1),
+ sha256: Sha256Digest($sha256),
+ sha384: Sha384Digest($sha384),
+ sha512: Sha512Digest($sha512),
+ }
+ };
+ }
+
+ // These test cases were generated using the following script. Each is a
+ // randomly-generated input, with each length between 1 and 128 bytes
+ // represented.
+ //
+ // # Generate 10000 bytes/20000 hex characters of random data
+ // function rand { dd if=/dev/urandom bs=1 count=10000 | hexdump -ve '1/1 "%.2x"'; }
+ //
+ // # Convert hex to raw bytes
+ // function hex_to_bytes { perl -pe 's/([0-9a-f]{2})/chr hex $1/gie'; }
+ //
+ // # Convert hex to a Rust array
+ // function hex_to_array { echo -n "["; while read -n 2 c; do echo -n "0x${c},";
+ // done; echo "]"; }
+ //
+ // # Usage: hash <input-hex> <hash>
+ // function hash { echo -n $(echo -n "$1" | hex_to_bytes | openssl dgst "-${2}" \
+ // | cut -d ' ' -f 1) | hex_to_array; }
+ //
+ // # Only even numbers of hex characters
+ // for i in `seq 2 2 256`; do
+ // INPUT=$(rand 2>/dev/null | head -c $i);
+ // echo 'test_case!'"($(echo -n ${INPUT} | hex_to_array), \
+ // $(hash ${INPUT} sha256), $(hash ${INPUT} sha384), $(hash ${INPUT} sha512)),";
+ // done
+ const TEST_CASES: &[TestCase] = &[
+ test_case!(
+ [0x81,],
+ [
+ 0xa3, 0xf2, 0x94, 0x23, 0x5f, 0xe5, 0x42, 0x20, 0x05, 0xae, 0x9b, 0xc3, 0xa0,
+ 0xd1, 0xbf, 0xfe, 0x12, 0xcf, 0xe3, 0x53,
+ ],
+ [
+ 0x59, 0x1b, 0x7c, 0xc9, 0x50, 0x37, 0x82, 0x2d, 0xec, 0x5a, 0x4d, 0x59, 0x3a,
+ 0x2e, 0x2e, 0x8b, 0x19, 0xc0, 0x7d, 0xdd, 0x25, 0x70, 0xe5, 0x69, 0x90, 0x03,
+ 0xd1, 0x7f, 0x14, 0xc4, 0x40, 0xa6,
+ ],
+ [
+ 0x1f, 0xe1, 0x9e, 0x83, 0xb5, 0x18, 0xc0, 0x34, 0x22, 0x46, 0x83, 0xc9, 0x6c,
+ 0x86, 0x90, 0x8e, 0x49, 0x1c, 0x09, 0x12, 0xdb, 0xfb, 0x2f, 0xb5, 0x10, 0xa2,
+ 0xa3, 0x56, 0xd8, 0xf7, 0xc0, 0x20, 0x0e, 0x16, 0x42, 0xcd, 0x74, 0x61, 0x28,
+ 0x1d, 0x9b, 0xa0, 0x6f, 0x6c, 0x70, 0x18, 0x0a, 0xd6,
+ ],
+ [
+ 0xc8, 0x41, 0x85, 0xc9, 0xa7, 0x89, 0x2e, 0x69, 0x44, 0x20, 0x9f, 0x89, 0xdb,
+ 0x2e, 0xec, 0xf4, 0x5d, 0x62, 0x2c, 0xf4, 0xcf, 0xff, 0x0c, 0xae, 0xb9, 0x2e,
+ 0x79, 0x51, 0xe3, 0x42, 0x54, 0x95, 0xb5, 0x07, 0xd1, 0x0b, 0xec, 0x92, 0x7e,
+ 0xce, 0x25, 0x31, 0xf2, 0x09, 0x58, 0x8f, 0xc6, 0xfa, 0x37, 0x51, 0x9f, 0xcd,
+ 0x82, 0xfa, 0xd4, 0x91, 0x66, 0xfe, 0x46, 0x89, 0x8a, 0x77, 0x73, 0x12,
+ ]
+ ),
+ test_case!(
+ [0xb0, 0x04,],
+ [
+ 0x6c, 0x1a, 0x3e, 0x76, 0xc0, 0xf3, 0x02, 0x1e, 0x96, 0xa8, 0x23, 0x6f, 0xae,
+ 0x9f, 0x61, 0x1d, 0xaa, 0x6a, 0xb9, 0x4f,
+ ],
+ [
+ 0xe8, 0xd9, 0x86, 0xb6, 0x05, 0x45, 0x24, 0xfc, 0x92, 0xe3, 0xac, 0xd6, 0x82,
+ 0x13, 0x76, 0x42, 0xdb, 0x72, 0x63, 0x07, 0x7f, 0xe5, 0xbd, 0x9d, 0x03, 0xa3,
+ 0xc2, 0xd1, 0x02, 0xd9, 0x4e, 0x47,
+ ],
+ [
+ 0xb7, 0xc9, 0xcf, 0x0e, 0xa1, 0xd7, 0x10, 0x1a, 0x23, 0xf2, 0x30, 0x9f, 0x35,
+ 0x89, 0xfd, 0x96, 0x48, 0x3c, 0xdf, 0x3f, 0x92, 0x84, 0x25, 0xbe, 0xf3, 0xb6,
+ 0xdf, 0xdd, 0xa9, 0x53, 0x04, 0xe2, 0x1b, 0x94, 0x05, 0xe7, 0xc2, 0xa4, 0xde,
+ 0x77, 0x0c, 0xea, 0xb2, 0xd1, 0x34, 0x6d, 0x24, 0x7b,
+ ],
+ [
+ 0xeb, 0xe3, 0xe7, 0x18, 0xe7, 0xef, 0xfc, 0xa8, 0x76, 0x4c, 0xd0, 0x6d, 0x64,
+ 0x52, 0xd1, 0x57, 0x6a, 0x2e, 0x2b, 0xcc, 0xc8, 0x53, 0xe2, 0x62, 0x91, 0xfa,
+ 0x8a, 0x8a, 0x9a, 0xf0, 0x7e, 0x3b, 0x56, 0xa1, 0xf9, 0x6e, 0x51, 0xe5, 0x4b,
+ 0x52, 0xc2, 0xfe, 0x48, 0xb8, 0x3d, 0xa7, 0xb9, 0x11, 0xd7, 0x96, 0xa0, 0xa6,
+ 0xf7, 0x61, 0xb3, 0xd9, 0x21, 0x78, 0x48, 0x7f, 0x21, 0x0a, 0xfe, 0x7a,
+ ]
+ ),
+ test_case!(
+ [0xdd, 0x6f, 0x24,],
+ [
+ 0x1b, 0xb4, 0x6d, 0x86, 0xef, 0xb7, 0xc8, 0x0f, 0x38, 0xd1, 0x9b, 0x36, 0xc1,
+ 0xe2, 0x22, 0xa6, 0xee, 0x97, 0x4d, 0x14,
+ ],
+ [
+ 0x69, 0xe1, 0x07, 0x53, 0x8a, 0xb7, 0x44, 0x1c, 0xd0, 0xeb, 0x6a, 0x1f, 0x4f,
+ 0x55, 0xe7, 0x1b, 0xdc, 0x6b, 0x1f, 0xe0, 0xa5, 0xae, 0x16, 0x89, 0x83, 0x29,
+ 0xdc, 0x86, 0x51, 0x1f, 0x03, 0x60,
+ ],
+ [
+ 0xe6, 0x08, 0xf5, 0x30, 0x24, 0x0d, 0x9c, 0xd6, 0x0b, 0x91, 0x58, 0x22, 0x01,
+ 0x88, 0x6c, 0x50, 0x15, 0xef, 0x6f, 0xbc, 0x62, 0x6c, 0x2a, 0xfa, 0xa0, 0x1d,
+ 0xc2, 0xa5, 0xf6, 0x57, 0x9f, 0x35, 0x61, 0x02, 0xa8, 0x2c, 0x07, 0x11, 0x21,
+ 0xf2, 0x10, 0xf9, 0x37, 0x04, 0xdf, 0xe4, 0xa5, 0xa9,
+ ],
+ [
+ 0x08, 0x1a, 0x0f, 0xda, 0xae, 0x84, 0xd5, 0xe1, 0x39, 0xa8, 0xa7, 0xd7, 0x1f,
+ 0xd3, 0xe9, 0x2a, 0x7e, 0x47, 0xd1, 0x5f, 0xe7, 0xf3, 0x16, 0xdc, 0x1b, 0x21,
+ 0x1b, 0xeb, 0xbd, 0xec, 0xbb, 0xf2, 0x3a, 0xfb, 0xda, 0x51, 0x7c, 0xdb, 0x95,
+ 0x87, 0x32, 0xdb, 0x44, 0xfd, 0xce, 0xe9, 0x25, 0xee, 0x85, 0x48, 0x3c, 0x1d,
+ 0x95, 0x60, 0x88, 0xcb, 0x45, 0x30, 0xa9, 0x0e, 0x6b, 0xea, 0x23, 0x6d,
+ ]
+ ),
+ test_case!(
+ [0x5a, 0x37, 0x17, 0x5b,],
+ [
+ 0x06, 0xf9, 0x8e, 0x7e, 0xc1, 0xc6, 0x31, 0x29, 0xef, 0x02, 0x17, 0x93, 0x70,
+ 0x34, 0x3e, 0x8f, 0x17, 0xca, 0xa7, 0x2c,
+ ],
+ [
+ 0xe6, 0x91, 0x73, 0xa1, 0xc0, 0xbb, 0xce, 0xc0, 0x7d, 0xef, 0x7e, 0x20, 0x48,
+ 0x02, 0xf9, 0x96, 0x8f, 0x0b, 0xc6, 0x47, 0x1a, 0x17, 0x84, 0x50, 0x4d, 0xd3,
+ 0xf7, 0x85, 0xe7, 0x4e, 0x83, 0xa7,
+ ],
+ [
+ 0x1a, 0x1b, 0x23, 0x3f, 0x2f, 0x38, 0x91, 0x35, 0x28, 0xfa, 0x8a, 0x64, 0xf6,
+ 0xf7, 0x36, 0x47, 0xf9, 0x84, 0x67, 0x80, 0x83, 0xe8, 0xbd, 0x2b, 0xcd, 0x8d,
+ 0x5f, 0x0b, 0x29, 0xb2, 0x60, 0xba, 0x88, 0x84, 0x54, 0x9a, 0x67, 0xcb, 0x74,
+ 0x02, 0x75, 0xe8, 0xb2, 0xd7, 0xd7, 0x27, 0xa3, 0x72,
+ ],
+ [
+ 0x7f, 0xbc, 0x99, 0xa2, 0xce, 0x12, 0x99, 0x22, 0xf1, 0x8a, 0x46, 0x0f, 0xd8,
+ 0xf4, 0x08, 0x3a, 0xd2, 0xd8, 0x0f, 0x59, 0x99, 0x3f, 0x5a, 0x21, 0xa7, 0xdf,
+ 0xa4, 0x49, 0x94, 0xcf, 0x75, 0x25, 0x4f, 0xc4, 0x6f, 0x57, 0x6a, 0x60, 0xf8,
+ 0x34, 0x2b, 0xdc, 0x17, 0x2b, 0xed, 0xe7, 0x84, 0x5e, 0xa1, 0xb8, 0x5b, 0x49,
+ 0x84, 0xa7, 0x58, 0x03, 0x6e, 0x8e, 0x6b, 0x3b, 0x6d, 0x2f, 0x9d, 0x83,
+ ]
+ ),
+ test_case!(
+ [0x81, 0x30, 0x79, 0xfd, 0xb7,],
+ [
+ 0x56, 0x13, 0xb1, 0x9d, 0x6e, 0x17, 0x88, 0xb7, 0x88, 0xe8, 0xd2, 0x96, 0x3c,
+ 0x94, 0x2e, 0xc8, 0xbe, 0xd5, 0xec, 0x23,
+ ],
+ [
+ 0xb1, 0xd3, 0x71, 0xc8, 0x54, 0x7d, 0x15, 0x4c, 0x0a, 0x73, 0x4f, 0x62, 0x85,
+ 0xa7, 0x2d, 0x20, 0x98, 0xcd, 0xbc, 0x83, 0x0d, 0x54, 0x90, 0xef, 0x72, 0xd2,
+ 0x9f, 0xa2, 0x7f, 0x98, 0x85, 0x93,
+ ],
+ [
+ 0xba, 0xcc, 0x19, 0x8d, 0x5d, 0x03, 0xcb, 0x8e, 0xcb, 0x0b, 0xfb, 0x48, 0x2e,
+ 0x4b, 0xa0, 0x40, 0xef, 0xd5, 0x4a, 0xfc, 0x90, 0xdb, 0x9d, 0xae, 0x88, 0x08,
+ 0x7e, 0x94, 0x04, 0x58, 0x15, 0x74, 0x82, 0x49, 0xbf, 0xee, 0x1f, 0x9a, 0x96,
+ 0xa9, 0x73, 0xb5, 0x21, 0x18, 0xaf, 0x51, 0x8e, 0x5d,
+ ],
+ [
+ 0xba, 0x90, 0x06, 0xe0, 0xc3, 0xc6, 0xd3, 0x94, 0xc5, 0x3d, 0x20, 0x14, 0x91,
+ 0xb3, 0x06, 0x97, 0xfa, 0xe9, 0x5f, 0x99, 0x11, 0x72, 0x79, 0xf1, 0x74, 0x0e,
+ 0xe1, 0x06, 0x6b, 0x60, 0xaa, 0x3f, 0x9c, 0xc7, 0x10, 0xae, 0xf0, 0x05, 0x28,
+ 0xdb, 0x26, 0x60, 0xa9, 0x00, 0xfb, 0xcb, 0x5f, 0x34, 0xbf, 0xd6, 0x4b, 0x15,
+ 0x5f, 0x6a, 0xad, 0xa3, 0xbc, 0x9a, 0x76, 0x8e, 0xef, 0x46, 0x36, 0xd8,
+ ]
+ ),
+ test_case!(
+ [0x70, 0xe4, 0x89, 0xe4, 0x36, 0xf9,],
+ [
+ 0xaf, 0x8f, 0x2c, 0x4e, 0xc2, 0xab, 0x44, 0x5c, 0xfd, 0xd2, 0x00, 0xa4, 0x65,
+ 0x84, 0x53, 0xc3, 0xd8, 0x66, 0x63, 0x1f,
+ ],
+ [
+ 0x7a, 0xb9, 0xd9, 0x45, 0x32, 0xdf, 0xde, 0x31, 0x8b, 0xc2, 0x85, 0xcc, 0xac,
+ 0xcf, 0x84, 0x1e, 0x0a, 0x1c, 0xcb, 0x7b, 0x5b, 0x62, 0x69, 0x40, 0x05, 0xea,
+ 0xfd, 0x44, 0x4e, 0x21, 0x82, 0xf2,
+ ],
+ [
+ 0xcc, 0x71, 0xc7, 0xff, 0x3c, 0xd6, 0xbd, 0x00, 0x31, 0x00, 0xea, 0xeb, 0xbc,
+ 0x05, 0x93, 0x17, 0x43, 0x56, 0xae, 0xe7, 0x54, 0xfc, 0xe6, 0x74, 0x4c, 0x05,
+ 0xba, 0x9e, 0xd2, 0x9c, 0x93, 0xf0, 0x6d, 0x27, 0xbc, 0x2c, 0x5e, 0x7c, 0x60,
+ 0xfb, 0x23, 0xbf, 0x60, 0x72, 0xff, 0xe6, 0xde, 0x64,
+ ],
+ [
+ 0x19, 0x13, 0x01, 0x29, 0xdb, 0x6b, 0xb0, 0xc5, 0x1a, 0x39, 0xb9, 0xa7, 0xfb,
+ 0xf3, 0xa7, 0x3e, 0x74, 0xae, 0x5f, 0x46, 0xfd, 0x0d, 0xda, 0x9e, 0x17, 0xc8,
+ 0xb8, 0xee, 0x36, 0x2b, 0x53, 0x6c, 0x46, 0xcb, 0xc2, 0x72, 0xb4, 0x6c, 0xc7,
+ 0x55, 0xa3, 0x7e, 0x5e, 0x39, 0x37, 0x03, 0x31, 0xf8, 0x31, 0x0f, 0xef, 0xc1,
+ 0x9c, 0x82, 0x91, 0x57, 0x85, 0x3c, 0x8c, 0x8e, 0x0c, 0x83, 0xc3, 0x23,
+ ]
+ ),
+ test_case!(
+ [0x51, 0x0f, 0x6a, 0x5e, 0x95, 0x09, 0x95,],
+ [
+ 0x35, 0x9e, 0x21, 0xea, 0xa5, 0x98, 0x2a, 0x53, 0xcf, 0xcc, 0x3a, 0xbf, 0x65,
+ 0xfb, 0xa5, 0x8a, 0x0f, 0x72, 0x29, 0xa0,
+ ],
+ [
+ 0x2c, 0x7b, 0xd8, 0x76, 0x53, 0xb2, 0x67, 0xfa, 0x35, 0x50, 0xf1, 0x94, 0xf3,
+ 0x65, 0xf8, 0x0f, 0x76, 0x51, 0xfb, 0x41, 0x25, 0xc3, 0xc0, 0x7a, 0xfe, 0x85,
+ 0x58, 0xb9, 0x30, 0xe2, 0x53, 0xc2,
+ ],
+ [
+ 0xd0, 0x70, 0x84, 0x34, 0xe6, 0x5a, 0xf4, 0xb5, 0x66, 0xc8, 0x68, 0x68, 0xac,
+ 0xfd, 0x58, 0x1a, 0xae, 0xe0, 0x68, 0x80, 0xec, 0x2d, 0x5f, 0x22, 0x05, 0x1e,
+ 0xe3, 0x3e, 0x93, 0xb4, 0x72, 0x70, 0x1c, 0xae, 0x21, 0x8b, 0x03, 0xb7, 0x62,
+ 0x1a, 0xf5, 0x0b, 0xe4, 0x02, 0xbf, 0x5b, 0x5c, 0x2b,
+ ],
+ [
+ 0x27, 0x6a, 0x6f, 0xf5, 0xed, 0xdf, 0xd4, 0x79, 0xa3, 0xd7, 0x7e, 0x0f, 0xe0,
+ 0xfe, 0x1a, 0xae, 0xd6, 0x28, 0xf1, 0xb3, 0xe5, 0x0c, 0x7b, 0x82, 0xcb, 0x69,
+ 0x06, 0xb5, 0xed, 0xd0, 0x66, 0x4f, 0xba, 0x38, 0x95, 0x67, 0x20, 0xe0, 0x18,
+ 0xe7, 0xa2, 0x14, 0x14, 0xbf, 0x8d, 0x03, 0xa9, 0x48, 0xf4, 0x44, 0x5f, 0x7d,
+ 0x19, 0xd7, 0x0e, 0xab, 0x01, 0xe2, 0x70, 0xfe, 0x56, 0xea, 0xc0, 0x1d,
+ ]
+ ),
+ test_case!(
+ [0x65, 0x2f, 0xd2, 0x1c, 0x7e, 0x7a, 0xcc, 0x2b,],
+ [
+ 0x28, 0xfe, 0x15, 0xde, 0x85, 0x56, 0xb3, 0xd2, 0xc7, 0x20, 0x45, 0x0a, 0xed,
+ 0x3a, 0x9e, 0x7b, 0x2e, 0x27, 0xe4, 0xab,
+ ],
+ [
+ 0x9c, 0xe7, 0x53, 0x27, 0x12, 0x0b, 0x72, 0x1f, 0xe3, 0x10, 0x60, 0x97, 0x3f,
+ 0x4b, 0xf8, 0x71, 0x77, 0x14, 0x57, 0xa3, 0x40, 0xfd, 0x00, 0xaa, 0x9c, 0x74,
+ 0xc5, 0xfd, 0x17, 0xc5, 0x09, 0xb6,
+ ],
+ [
+ 0xcf, 0xc5, 0x9a, 0x8b, 0xd1, 0xa6, 0x73, 0x5e, 0x40, 0xee, 0xb6, 0x61, 0x1b,
+ 0x0a, 0xb3, 0x16, 0x7e, 0x95, 0xf7, 0x1a, 0xeb, 0x0e, 0x63, 0x2f, 0x56, 0x25,
+ 0x38, 0x89, 0xf4, 0xda, 0x40, 0x9e, 0xda, 0x9b, 0x80, 0x11, 0x4e, 0xb2, 0xf9,
+ 0x76, 0x30, 0x52, 0x50, 0x5e, 0x2a, 0xd0, 0x9d, 0x5f,
+ ],
+ [
+ 0x82, 0xd4, 0x37, 0xbe, 0x30, 0xd7, 0x9e, 0x76, 0xec, 0x99, 0x47, 0x64, 0x06,
+ 0xc0, 0x32, 0x76, 0xdf, 0xeb, 0x5c, 0x72, 0x7e, 0xcd, 0x7d, 0x51, 0x86, 0x87,
+ 0x20, 0xb8, 0xd7, 0x1a, 0x93, 0x0c, 0x25, 0xb2, 0xa5, 0xd2, 0xa1, 0xbe, 0x1f,
+ 0xdc, 0x6b, 0x49, 0x1a, 0x62, 0x37, 0xfe, 0xe6, 0x34, 0x7c, 0x25, 0x3c, 0x2d,
+ 0xc8, 0x22, 0x51, 0x2b, 0x3b, 0x85, 0x6a, 0x77, 0x82, 0xd8, 0xf0, 0xf7,
+ ]
+ ),
+ test_case!(
+ [0x33, 0xde, 0x9a, 0x6f, 0x4b, 0x6e, 0x51, 0x44, 0x3b,],
+ [
+ 0x35, 0x8c, 0x77, 0x96, 0xc5, 0xd5, 0xeb, 0xd6, 0xed, 0x5e, 0x8e, 0x38, 0xa0,
+ 0x3d, 0x73, 0x82, 0xf3, 0x82, 0xc9, 0x62,
+ ],
+ [
+ 0x24, 0x96, 0xf0, 0xeb, 0xe4, 0xc3, 0x93, 0x00, 0xb7, 0xdf, 0xdc, 0xf3, 0xe2,
+ 0xcd, 0x37, 0xd8, 0x5b, 0x2b, 0xf1, 0x93, 0xdb, 0x83, 0xd7, 0x21, 0x98, 0x78,
+ 0xda, 0xb9, 0x7b, 0xb5, 0x82, 0xbb,
+ ],
+ [
+ 0x3c, 0x5d, 0xff, 0x66, 0xfd, 0x9c, 0x53, 0xaa, 0x17, 0x98, 0x7d, 0x72, 0x94,
+ 0xff, 0x93, 0x44, 0xaf, 0x69, 0xd1, 0x56, 0x46, 0x0e, 0x49, 0x2d, 0xe7, 0xe5,
+ 0xa5, 0x99, 0x1f, 0x74, 0xc3, 0xdb, 0xe7, 0x13, 0x5c, 0x10, 0xf1, 0x25, 0xe4,
+ 0xbf, 0xda, 0x72, 0x96, 0xb6, 0x06, 0xb4, 0x48, 0x6b,
+ ],
+ [
+ 0xde, 0xa9, 0x04, 0x76, 0x63, 0x59, 0xaa, 0x33, 0xc0, 0x9c, 0xb8, 0xb2, 0x76,
+ 0x37, 0x47, 0x52, 0x58, 0x71, 0x92, 0xf9, 0xb1, 0x90, 0xed, 0xc1, 0x8d, 0x42,
+ 0x97, 0x98, 0xe1, 0xe0, 0x1b, 0xdb, 0x87, 0x68, 0x6d, 0xd5, 0xea, 0x34, 0x0f,
+ 0xf6, 0x20, 0x8d, 0xa3, 0xbf, 0x6b, 0x27, 0x35, 0xf7, 0x0d, 0x72, 0x93, 0x74,
+ 0xab, 0xcf, 0xe9, 0xfc, 0xec, 0xb8, 0x36, 0x0c, 0x36, 0x75, 0xc0, 0x40,
+ ]
+ ),
+ test_case!(
+ [0x55, 0xc3, 0xd5, 0x66, 0x3c, 0x18, 0x19, 0x5e, 0x95, 0x6b,],
+ [
+ 0x35, 0x63, 0xcf, 0x0a, 0xae, 0xc6, 0x33, 0x1e, 0x46, 0xc4, 0xb3, 0x3c, 0x1c,
+ 0xf3, 0x93, 0x3e, 0xe5, 0x90, 0xa3, 0xc3,
+ ],
+ [
+ 0x05, 0x59, 0xaa, 0x90, 0xe0, 0x7d, 0x27, 0x46, 0x2c, 0x25, 0xc8, 0x82, 0xe4,
+ 0xc9, 0x65, 0xf3, 0x65, 0x9d, 0xdb, 0x25, 0x3e, 0x19, 0x8f, 0x39, 0x54, 0x47,
+ 0x99, 0x40, 0x3b, 0xd6, 0x8b, 0x2d,
+ ],
+ [
+ 0xfe, 0xaf, 0x33, 0xaa, 0x94, 0x65, 0x45, 0xba, 0xf1, 0xb8, 0xee, 0xd2, 0xea,
+ 0xc2, 0x26, 0x1b, 0x87, 0x96, 0x6a, 0xd6, 0x5a, 0x13, 0xa4, 0x82, 0x7a, 0x92,
+ 0xed, 0xd9, 0xa8, 0xe3, 0xbe, 0x12, 0x6e, 0xc5, 0x99, 0xe9, 0xc5, 0x50, 0xea,
+ 0x01, 0xe2, 0x8e, 0xc4, 0xb9, 0x9b, 0x79, 0x9a, 0x10,
+ ],
+ [
+ 0xdf, 0x32, 0xa2, 0x82, 0x4a, 0x6a, 0xfb, 0x64, 0x6e, 0xbb, 0xef, 0xc2, 0xab,
+ 0xeb, 0x7a, 0xac, 0xd1, 0x09, 0x97, 0xe4, 0xcc, 0x3b, 0x22, 0x66, 0x1f, 0x47,
+ 0x9e, 0x9d, 0x87, 0x42, 0xa3, 0x5e, 0x37, 0xd8, 0x6d, 0x83, 0x31, 0x79, 0x96,
+ 0x93, 0x4c, 0x04, 0x5f, 0x3d, 0x75, 0x99, 0x78, 0x71, 0xc3, 0x77, 0x1b, 0x67,
+ 0x2d, 0x15, 0x9a, 0x83, 0x6c, 0xc7, 0x13, 0x83, 0xb1, 0x76, 0xb1, 0x64,
+ ]
+ ),
+ test_case!(
+ [0x2c, 0xb1, 0xc2, 0xeb, 0xac, 0xe0, 0x7a, 0x32, 0x7d, 0xf0, 0x1a,],
+ [
+ 0x9b, 0x8c, 0x27, 0xdc, 0x0d, 0x65, 0xc6, 0x9d, 0xce, 0x21, 0x2c, 0x99, 0x43,
+ 0xb5, 0x75, 0x11, 0x9a, 0x4d, 0x55, 0x5f,
+ ],
+ [
+ 0x5a, 0xbe, 0x3b, 0x6d, 0x5b, 0x4d, 0x9f, 0x70, 0xca, 0x73, 0x66, 0x76, 0x63,
+ 0x86, 0xd0, 0x34, 0x1e, 0xe4, 0xb2, 0xff, 0x4d, 0x57, 0x40, 0xcf, 0xd5, 0x9a,
+ 0x84, 0x22, 0xf2, 0x53, 0x8c, 0x70,
+ ],
+ [
+ 0x80, 0xd2, 0x9c, 0x92, 0x06, 0xfa, 0xc9, 0x06, 0xa0, 0xf1, 0x78, 0x7b, 0xe8,
+ 0x34, 0x65, 0xdf, 0x22, 0xec, 0xaf, 0x11, 0x3b, 0x88, 0x17, 0xba, 0x89, 0x83,
+ 0xe5, 0x71, 0x49, 0xd8, 0xa1, 0xdd, 0x3e, 0xb4, 0xa6, 0xcc, 0x90, 0xa7, 0xbe,
+ 0xad, 0xd0, 0xcb, 0x65, 0x53, 0xd5, 0x56, 0x39, 0x6f,
+ ],
+ [
+ 0x21, 0x7f, 0x8e, 0xe2, 0x16, 0x05, 0x96, 0xd0, 0xd7, 0x12, 0x5d, 0xd2, 0x91,
+ 0x5d, 0xb9, 0xfd, 0x54, 0xac, 0x3d, 0xb3, 0x1e, 0x40, 0x0c, 0x29, 0xc5, 0x43,
+ 0x0b, 0xbd, 0x6b, 0x25, 0x82, 0x40, 0x0b, 0x05, 0xff, 0x73, 0xf3, 0xa3, 0x6d,
+ 0x75, 0xdd, 0xc2, 0xdf, 0x17, 0xb9, 0x45, 0xd4, 0x82, 0x26, 0x7a, 0x56, 0xe3,
+ 0xf0, 0x60, 0xe1, 0xe0, 0x54, 0x64, 0x34, 0x71, 0x32, 0x6d, 0x04, 0xcd,
+ ]
+ ),
+ test_case!(
+ [0x34, 0x3f, 0x7c, 0x83, 0x97, 0x7a, 0xd7, 0x5e, 0x19, 0x84, 0x99, 0xe2,],
+ [
+ 0xd7, 0xdb, 0xef, 0x4a, 0xb6, 0x0e, 0x3a, 0x0a, 0xda, 0x14, 0x07, 0x50, 0xde,
+ 0xde, 0x23, 0xa6, 0xe1, 0x23, 0x96, 0x6d,
+ ],
+ [
+ 0x2b, 0x7a, 0x77, 0x7b, 0x16, 0x52, 0x05, 0x7e, 0x9d, 0x0e, 0x31, 0x84, 0xf3,
+ 0x61, 0x43, 0x12, 0xd8, 0x6f, 0x65, 0xaa, 0xcc, 0x49, 0x53, 0xab, 0xa4, 0x26,
+ 0xd7, 0xf8, 0x4c, 0xfd, 0x90, 0x15,
+ ],
+ [
+ 0x09, 0x7f, 0x80, 0x2a, 0xa2, 0xef, 0x2e, 0x1d, 0xce, 0xa0, 0x0e, 0x20, 0xde,
+ 0xe4, 0xe7, 0xd0, 0xa1, 0x85, 0x07, 0x7b, 0xec, 0x60, 0xeb, 0xe8, 0x23, 0x9a,
+ 0x15, 0x0d, 0x7c, 0x37, 0x19, 0x66, 0x73, 0x75, 0x2a, 0x42, 0x31, 0x8e, 0x13,
+ 0xe5, 0x13, 0x6c, 0xdf, 0x17, 0xde, 0x71, 0x2d, 0x29,
+ ],
+ [
+ 0xb6, 0x64, 0xf9, 0x86, 0xbd, 0xd6, 0xa4, 0xda, 0x34, 0xcc, 0xcb, 0xbf, 0xc9,
+ 0xa8, 0x50, 0x1b, 0xa6, 0xee, 0x3a, 0xd4, 0xa8, 0x6a, 0x29, 0x4d, 0xe7, 0xd4,
+ 0xcb, 0x01, 0x31, 0x9e, 0xa9, 0x05, 0x36, 0x78, 0x6d, 0x79, 0xa0, 0xb3, 0xb1,
+ 0x02, 0x12, 0x78, 0x2e, 0x4a, 0x98, 0x02, 0x50, 0x62, 0xe1, 0xac, 0x0a, 0x28,
+ 0x90, 0x2e, 0xb4, 0x1b, 0xb2, 0xad, 0x0c, 0x38, 0x82, 0x5e, 0xde, 0x51,
+ ]
+ ),
+ test_case!(
+ [0xf6, 0x15, 0xa0, 0x82, 0x3c, 0x18, 0x48, 0x01, 0xd6, 0xd1, 0xa9, 0x67, 0xa4,],
+ [
+ 0x46, 0x63, 0xa6, 0xcb, 0xab, 0xca, 0xd9, 0x28, 0x72, 0xee, 0x87, 0xa2, 0x39,
+ 0xab, 0x8d, 0x47, 0x49, 0x7f, 0x06, 0x38,
+ ],
+ [
+ 0xf5, 0x57, 0xec, 0x18, 0xa9, 0xbe, 0x7d, 0x44, 0xef, 0xff, 0xf6, 0xcd, 0xab,
+ 0x40, 0x30, 0x5c, 0x98, 0x5c, 0x0e, 0x38, 0xe6, 0x1b, 0xac, 0x9d, 0xee, 0x51,
+ 0x24, 0x4e, 0xc1, 0xa6, 0x23, 0x0d,
+ ],
+ [
+ 0xb7, 0x50, 0x8e, 0x49, 0x45, 0x53, 0x76, 0x6a, 0x46, 0xbd, 0x0f, 0x08, 0xea,
+ 0xa2, 0x15, 0x68, 0x59, 0xa3, 0x34, 0x25, 0x7a, 0x59, 0xbe, 0xa9, 0x0a, 0xf0,
+ 0xe7, 0x8c, 0xe8, 0xd2, 0x95, 0xd5, 0xfc, 0x96, 0xdd, 0x07, 0x1b, 0xde, 0x38,
+ 0x2c, 0xae, 0xbc, 0xae, 0x84, 0xe3, 0xa1, 0x69, 0xdf,
+ ],
+ [
+ 0x68, 0xe9, 0xfd, 0xec, 0x46, 0x65, 0xc0, 0xdd, 0x3b, 0x88, 0x62, 0xc7, 0x3e,
+ 0x77, 0xee, 0xb3, 0xd4, 0x57, 0x7f, 0xb7, 0x65, 0x01, 0xe0, 0xeb, 0xa7, 0x55,
+ 0xbb, 0x98, 0xca, 0x4d, 0x1f, 0xe8, 0x22, 0xaf, 0x04, 0x8e, 0xdb, 0x8f, 0xd3,
+ 0x7c, 0x06, 0x3a, 0xcb, 0x49, 0x2f, 0xbf, 0xd5, 0x3d, 0x51, 0x3d, 0xb5, 0x50,
+ 0xbb, 0x26, 0xc8, 0x14, 0xd2, 0x62, 0x58, 0xb6, 0xe4, 0x1f, 0x39, 0x5f,
+ ]
+ ),
+ test_case!(
+ [
+ 0xa7, 0xb5, 0x09, 0x64, 0x25, 0xf8, 0x20, 0xd0, 0x8a, 0xb9, 0x3c, 0xf8, 0x7c,
+ 0x8d,
+ ],
+ [
+ 0x6c, 0xe1, 0x00, 0x85, 0x8d, 0x28, 0x61, 0x8f, 0x62, 0x7b, 0xfb, 0x3e, 0xe6,
+ 0x4f, 0x0c, 0xdb, 0x50, 0xcb, 0xef, 0xc1,
+ ],
+ [
+ 0x49, 0x2a, 0x83, 0xb0, 0xaf, 0xf8, 0x83, 0x08, 0x43, 0xdc, 0x6f, 0xbe, 0x8b,
+ 0x14, 0xf7, 0x69, 0xad, 0x6b, 0x72, 0x97, 0x8f, 0xb9, 0xf8, 0xf5, 0x0a, 0x0e,
+ 0xb0, 0x1b, 0x99, 0x80, 0x3b, 0xb2,
+ ],
+ [
+ 0xb3, 0x17, 0x37, 0x7d, 0x75, 0xde, 0xc7, 0x19, 0x6a, 0x56, 0xca, 0xe0, 0x37,
+ 0xa8, 0xd3, 0x08, 0xca, 0x04, 0x0e, 0x85, 0x14, 0x62, 0x1d, 0x6a, 0xe9, 0xfb,
+ 0x80, 0xf0, 0x8d, 0x0d, 0xc0, 0x89, 0x11, 0xef, 0xf0, 0x7a, 0xb8, 0x0f, 0x50,
+ 0x02, 0x5c, 0xf5, 0xc9, 0x62, 0x4a, 0x94, 0x9b, 0x0f,
+ ],
+ [
+ 0x6d, 0xfc, 0x8f, 0x27, 0x92, 0x80, 0x09, 0x39, 0x32, 0xf1, 0x8d, 0x2f, 0xd9,
+ 0x8b, 0x8b, 0xa2, 0x53, 0x1c, 0x3e, 0x8b, 0x72, 0xb3, 0x55, 0xaa, 0x3b, 0x68,
+ 0xe7, 0x63, 0x6e, 0xbc, 0x03, 0xa7, 0x3f, 0x2e, 0xc2, 0x6c, 0x60, 0xae, 0xab,
+ 0x9d, 0xab, 0xfd, 0x3e, 0x05, 0x43, 0x9f, 0xaf, 0xd5, 0xf6, 0x3b, 0x75, 0xc6,
+ 0x72, 0xf5, 0x5e, 0x23, 0x55, 0x2d, 0x97, 0x26, 0xb6, 0xf3, 0x85, 0xe7,
+ ]
+ ),
+ test_case!(
+ [
+ 0xd5, 0x74, 0x8a, 0xd1, 0xa3, 0x93, 0xd0, 0x09, 0xfb, 0xed, 0xee, 0x43, 0x7a,
+ 0x50, 0x49,
+ ],
+ [
+ 0x13, 0x97, 0x62, 0x02, 0xbc, 0xc5, 0x6b, 0xd4, 0x33, 0xba, 0xca, 0x0e, 0xd6,
+ 0xa5, 0x47, 0x45, 0x4c, 0x9b, 0x06, 0xda,
+ ],
+ [
+ 0xed, 0xdf, 0x3b, 0x8b, 0x62, 0x2f, 0xda, 0x42, 0x14, 0x86, 0x71, 0xe6, 0x86,
+ 0xac, 0x56, 0xd6, 0x91, 0x99, 0x4d, 0x88, 0x1c, 0x09, 0xf1, 0x2b, 0x73, 0x79,
+ 0x5f, 0x1b, 0x63, 0xf6, 0x86, 0xfe,
+ ],
+ [
+ 0xa6, 0xeb, 0x40, 0xdc, 0x71, 0x9c, 0x20, 0xfb, 0xaa, 0x61, 0x16, 0xcd, 0x94,
+ 0xff, 0x9f, 0x60, 0x69, 0xfa, 0xee, 0x03, 0xb2, 0x1c, 0x1e, 0x59, 0xb0, 0xdd,
+ 0xff, 0xd7, 0x15, 0x45, 0xf2, 0x29, 0x24, 0x9d, 0x3e, 0x76, 0xc7, 0xf7, 0xd5,
+ 0x1d, 0xef, 0x9f, 0xc1, 0x78, 0x4e, 0x0a, 0xe7, 0xae,
+ ],
+ [
+ 0x00, 0x0d, 0xfa, 0x4c, 0xb8, 0x07, 0x25, 0x75, 0x2f, 0x58, 0x50, 0xcc, 0x72,
+ 0xef, 0x10, 0x87, 0x28, 0xee, 0x6b, 0xb1, 0xe7, 0xe4, 0xe4, 0xfd, 0xeb, 0xd8,
+ 0xe8, 0xb9, 0x6b, 0xab, 0x92, 0xa8, 0x32, 0x1b, 0xb7, 0x55, 0x3b, 0x30, 0xc5,
+ 0x98, 0x97, 0x32, 0xea, 0xf2, 0x76, 0x84, 0x0b, 0x68, 0x32, 0xf8, 0x99, 0xcb,
+ 0x47, 0x63, 0x4b, 0x13, 0x16, 0x2c, 0x30, 0x13, 0xd3, 0x59, 0x93, 0xb0,
+ ]
+ ),
+ test_case!(
+ [
+ 0x65, 0x2e, 0x60, 0xa1, 0x3d, 0xbf, 0x8e, 0xdb, 0x65, 0xc5, 0xd3, 0xce, 0x24,
+ 0xa8, 0x28, 0xbd,
+ ],
+ [
+ 0xbe, 0x60, 0xc7, 0x04, 0xdd, 0x57, 0xf6, 0x42, 0xff, 0x59, 0x95, 0xba, 0xc6,
+ 0xdf, 0x42, 0x29, 0x86, 0xcb, 0x4d, 0x21,
+ ],
+ [
+ 0x10, 0xa8, 0x99, 0xd3, 0x86, 0xea, 0xcb, 0xed, 0x95, 0x9f, 0x72, 0xac, 0x68,
+ 0xfb, 0x0c, 0x5b, 0x9f, 0x09, 0xf5, 0x3c, 0x57, 0xac, 0xe1, 0x2c, 0xe3, 0x1c,
+ 0xc0, 0x2e, 0x48, 0x39, 0x8f, 0x6a,
+ ],
+ [
+ 0x2b, 0x80, 0xe6, 0xe2, 0xf7, 0x09, 0x59, 0xd1, 0xb6, 0x48, 0x07, 0x5b, 0x5b,
+ 0x30, 0x10, 0xb3, 0x49, 0xe2, 0xce, 0xf1, 0x13, 0x4d, 0x98, 0x4c, 0x3b, 0x83,
+ 0x93, 0xee, 0xb8, 0x4e, 0x10, 0x8a, 0xdd, 0x03, 0x2b, 0xaf, 0x5a, 0x2f, 0xe3,
+ 0x15, 0x35, 0xda, 0x7e, 0x9d, 0x14, 0xba, 0xbb, 0x77,
+ ],
+ [
+ 0xc7, 0x3b, 0x61, 0xca, 0x99, 0xde, 0x4f, 0x17, 0x62, 0x51, 0xde, 0x80, 0x50,
+ 0xf9, 0x14, 0x11, 0x4d, 0xff, 0xa1, 0x84, 0x54, 0x2d, 0x89, 0xb4, 0x63, 0xda,
+ 0xfe, 0x25, 0x54, 0x91, 0x2d, 0xa9, 0xd9, 0xed, 0xd1, 0x33, 0xab, 0xea, 0xc9,
+ 0x06, 0xa7, 0x72, 0xb2, 0x80, 0x8b, 0xb2, 0x7a, 0x36, 0x60, 0x7d, 0xa9, 0x20,
+ 0x0b, 0x41, 0xfa, 0x68, 0xca, 0x2c, 0x80, 0x3a, 0x77, 0x5b, 0x22, 0x14,
+ ]
+ ),
+ test_case!(
+ [
+ 0x9a, 0x7e, 0x4b, 0x4e, 0xe6, 0x80, 0xf6, 0x36, 0xa8, 0xf8, 0x71, 0xcd, 0xae,
+ 0xb8, 0xf9, 0xae, 0x23,
+ ],
+ [
+ 0x7b, 0x32, 0xd0, 0x64, 0x68, 0x02, 0xc8, 0x4f, 0x41, 0xaa, 0xfc, 0xb2, 0xfc,
+ 0xbe, 0xed, 0x2a, 0xee, 0x93, 0x3f, 0x4f,
+ ],
+ [
+ 0xea, 0x34, 0xbc, 0xd7, 0x7d, 0x84, 0xf3, 0x7f, 0x2f, 0x84, 0xeb, 0x04, 0xc9,
+ 0x00, 0xde, 0xd8, 0x5f, 0xd6, 0x4d, 0xbb, 0xc5, 0xed, 0x3c, 0x1f, 0x4d, 0x8e,
+ 0x77, 0x1e, 0xbb, 0xb5, 0x5c, 0xde,
+ ],
+ [
+ 0xbe, 0x9a, 0x02, 0x3d, 0xa1, 0x3f, 0x26, 0xbb, 0x6d, 0xab, 0x4f, 0x57, 0xaa,
+ 0x90, 0x12, 0x2b, 0x10, 0x6f, 0xbc, 0x8c, 0xf8, 0xfb, 0x7b, 0x6a, 0x74, 0x1a,
+ 0xd7, 0xb4, 0xeb, 0x43, 0x12, 0x72, 0xb1, 0xec, 0x59, 0xdd, 0xe1, 0xda, 0x15,
+ 0x6f, 0xc3, 0x93, 0x04, 0xfb, 0xd0, 0x78, 0x61, 0x94,
+ ],
+ [
+ 0xff, 0xda, 0x37, 0x32, 0x14, 0x3f, 0x97, 0x6f, 0xac, 0x64, 0x75, 0xb4, 0x8c,
+ 0x9c, 0xd9, 0x16, 0x87, 0x70, 0xd4, 0x27, 0xe9, 0x8e, 0x27, 0x2e, 0x7c, 0x08,
+ 0xc2, 0x21, 0x8c, 0xfe, 0x22, 0x5c, 0x39, 0xf0, 0x6c, 0x2a, 0x1d, 0x7e, 0x3e,
+ 0xa8, 0xeb, 0x39, 0xd2, 0xcd, 0x78, 0x8d, 0x2f, 0x6d, 0x13, 0xee, 0x16, 0x31,
+ 0x46, 0x06, 0xf0, 0xf2, 0x5b, 0x03, 0xc7, 0x11, 0xec, 0x33, 0x59, 0xd8,
+ ]
+ ),
+ test_case!(
+ [
+ 0xe4, 0x20, 0x5c, 0x7c, 0x8e, 0x25, 0x00, 0xc4, 0x3e, 0x8b, 0xfb, 0x19, 0x68,
+ 0x63, 0xa6, 0x2e, 0xc7, 0x23,
+ ],
+ [
+ 0xaa, 0x6c, 0xb1, 0x6b, 0xf8, 0x21, 0x74, 0x19, 0x9e, 0x96, 0xf6, 0xbd, 0xc5,
+ 0xad, 0x67, 0x5d, 0x06, 0x09, 0x3b, 0x28,
+ ],
+ [
+ 0x88, 0x49, 0x1d, 0xec, 0x62, 0x4e, 0x51, 0xad, 0xd9, 0xc0, 0xce, 0xf3, 0x7c,
+ 0x99, 0x98, 0x43, 0x5d, 0x04, 0x7c, 0xdf, 0xa2, 0x3e, 0x22, 0xbf, 0x34, 0x2a,
+ 0x66, 0x77, 0xe0, 0x19, 0x2f, 0xe5,
+ ],
+ [
+ 0x10, 0x59, 0xba, 0x48, 0x0e, 0xfd, 0xc0, 0x69, 0x20, 0x52, 0xe1, 0xa5, 0xe8,
+ 0xf3, 0xa6, 0x69, 0x88, 0xb6, 0x35, 0xd7, 0x2d, 0x14, 0x42, 0x87, 0x25, 0x1e,
+ 0x02, 0xfe, 0xbe, 0x58, 0x43, 0x36, 0xdc, 0xe7, 0xfd, 0xfd, 0x0f, 0x2a, 0x39,
+ 0x13, 0x60, 0x39, 0xad, 0xd8, 0x38, 0x13, 0x5d, 0x6c,
+ ],
+ [
+ 0xa9, 0x01, 0xf4, 0xc6, 0xe9, 0x6c, 0x8e, 0x76, 0xd1, 0xcb, 0xfa, 0x50, 0xa6,
+ 0x24, 0x8a, 0x0f, 0xdf, 0x64, 0x0e, 0xda, 0xc4, 0xf0, 0x79, 0xf0, 0x46, 0xaa,
+ 0x63, 0xc7, 0x8c, 0xf3, 0xce, 0xe1, 0x28, 0x7b, 0x03, 0x63, 0x47, 0xd4, 0x40,
+ 0xf8, 0x1f, 0x38, 0x09, 0x06, 0xd5, 0x86, 0x80, 0x21, 0x2a, 0x4d, 0x9d, 0x27,
+ 0xbf, 0xbf, 0xbe, 0x4e, 0x6c, 0x37, 0x5e, 0x89, 0xfa, 0x41, 0xe4, 0xe7,
+ ]
+ ),
+ test_case!(
+ [
+ 0x57, 0xc3, 0x48, 0x43, 0x9a, 0x40, 0xb4, 0x4a, 0x06, 0xff, 0x22, 0x1d, 0x90,
+ 0xed, 0x22, 0xa4, 0x8a, 0x03, 0x21,
+ ],
+ [
+ 0xd2, 0x4b, 0x43, 0xd6, 0x06, 0x63, 0x34, 0xf6, 0xf8, 0x2c, 0x5f, 0xca, 0xd2,
+ 0x85, 0x53, 0xa5, 0xed, 0x8a, 0x51, 0xec,
+ ],
+ [
+ 0xcd, 0x99, 0x4a, 0x59, 0x55, 0xff, 0x36, 0x74, 0xe5, 0xbe, 0x99, 0xd2, 0x32,
+ 0x63, 0x6e, 0x93, 0x57, 0xf1, 0xad, 0x7c, 0x68, 0x5a, 0x54, 0xdb, 0xce, 0x62,
+ 0xe7, 0xd8, 0xa0, 0x64, 0xbb, 0xed,
+ ],
+ [
+ 0xf2, 0x0d, 0x8e, 0x2a, 0x00, 0x38, 0xfc, 0x4e, 0xaa, 0xcb, 0x70, 0xe0, 0xcd,
+ 0xc8, 0x37, 0x5b, 0x35, 0x62, 0x4b, 0x65, 0xa5, 0xfc, 0x57, 0x52, 0xa1, 0x48,
+ 0x54, 0xd2, 0x56, 0x73, 0x43, 0xad, 0xac, 0xfd, 0xda, 0x3f, 0xa6, 0x00, 0x1c,
+ 0x46, 0x4a, 0xad, 0xea, 0x1e, 0x79, 0x73, 0x03, 0x05,
+ ],
+ [
+ 0x1e, 0x60, 0x4f, 0x67, 0xd6, 0xb4, 0xf5, 0x79, 0x4a, 0x5d, 0x8f, 0x81, 0x82,
+ 0xe1, 0x2a, 0x98, 0x00, 0x31, 0x3a, 0x2a, 0x5c, 0x1f, 0xc0, 0x21, 0xc8, 0xc2,
+ 0x6d, 0x89, 0x94, 0x2e, 0x91, 0x59, 0x8d, 0x58, 0x71, 0x82, 0x11, 0xc8, 0xc2,
+ 0x32, 0x42, 0x75, 0xcb, 0x18, 0x57, 0x1c, 0x1a, 0x77, 0x87, 0x0a, 0x60, 0xe6,
+ 0xbc, 0x89, 0xc6, 0x8e, 0x2f, 0x5d, 0x81, 0x51, 0xeb, 0xbb, 0x1f, 0x2d,
+ ]
+ ),
+ test_case!(
+ [
+ 0x07, 0x88, 0x5e, 0xe1, 0x7d, 0x31, 0x35, 0x5a, 0x13, 0xa8, 0x36, 0xac, 0xd1,
+ 0x95, 0xff, 0x0b, 0x99, 0x22, 0x5c, 0x2a,
+ ],
+ [
+ 0x05, 0xf0, 0x1f, 0xea, 0x63, 0xd9, 0x27, 0x6d, 0xa4, 0x19, 0xce, 0xaa, 0xad,
+ 0x29, 0xbd, 0x95, 0xd7, 0x51, 0x1e, 0xde,
+ ],
+ [
+ 0xb5, 0x3d, 0x9d, 0x4d, 0x15, 0x6b, 0xa6, 0xf6, 0x30, 0x69, 0x3b, 0xfd, 0xe1,
+ 0x6f, 0x4d, 0x8b, 0xe7, 0xa6, 0xc8, 0x35, 0x6f, 0xbc, 0x38, 0xb4, 0x43, 0x99,
+ 0x55, 0xef, 0x56, 0x9e, 0xce, 0x5a,
+ ],
+ [
+ 0xc7, 0x14, 0xd0, 0x55, 0xbc, 0x24, 0xee, 0xca, 0x91, 0x3f, 0xf8, 0x5e, 0x78,
+ 0x29, 0xca, 0xcc, 0x3d, 0xe9, 0x4e, 0xdb, 0x56, 0x69, 0x74, 0x14, 0x83, 0xf8,
+ 0xec, 0x27, 0xc2, 0xdb, 0x09, 0xab, 0x69, 0x5f, 0x09, 0x71, 0x2a, 0xcf, 0x4a,
+ 0xc9, 0x90, 0xa8, 0x00, 0x18, 0x96, 0x82, 0x97, 0x9b,
+ ],
+ [
+ 0x12, 0x9a, 0xfb, 0x1a, 0x2d, 0x1d, 0xee, 0x3a, 0x68, 0x6c, 0x7f, 0xea, 0x9e,
+ 0x1d, 0xb0, 0x97, 0x39, 0x5f, 0x94, 0x96, 0x24, 0xea, 0xb1, 0x73, 0x5f, 0x2a,
+ 0xa8, 0x10, 0xaa, 0x95, 0xae, 0xc4, 0x5e, 0x22, 0x5c, 0x17, 0xf8, 0x12, 0x51,
+ 0x7d, 0x75, 0xaa, 0x3d, 0x6c, 0x85, 0xdf, 0x81, 0x2f, 0xc1, 0xdd, 0x00, 0x50,
+ 0xb8, 0xd1, 0x47, 0xf5, 0x7e, 0xf9, 0xa1, 0xd0, 0xd6, 0x9f, 0xa6, 0xd9,
+ ]
+ ),
+ test_case!(
+ [
+ 0xf0, 0x00, 0x1a, 0xf6, 0x9a, 0xf1, 0x96, 0x07, 0x58, 0x0b, 0x2f, 0xad, 0x1d,
+ 0xfe, 0x5e, 0x0b, 0x92, 0xe9, 0x97, 0xcb, 0x64,
+ ],
+ [
+ 0x77, 0x7c, 0xcf, 0xaa, 0x8d, 0xd8, 0xfc, 0x1f, 0xed, 0x83, 0x5c, 0xfe, 0xd5,
+ 0xbd, 0x5d, 0x18, 0x6d, 0xd8, 0xfd, 0x1a,
+ ],
+ [
+ 0x1c, 0x92, 0x99, 0xee, 0x27, 0xf2, 0xaa, 0x93, 0xd4, 0x9f, 0x79, 0x43, 0xb0,
+ 0xaf, 0x91, 0xf6, 0x16, 0xbb, 0xeb, 0x3d, 0x2d, 0xe6, 0x9e, 0xfa, 0xe9, 0x2f,
+ 0x13, 0xec, 0xdf, 0xd9, 0x41, 0x7b,
+ ],
+ [
+ 0x4a, 0x54, 0x8b, 0x22, 0xb6, 0x6e, 0x73, 0x22, 0xd0, 0xd6, 0x1b, 0x5b, 0xf2,
+ 0x3f, 0xd2, 0x80, 0xf6, 0x72, 0xec, 0x37, 0x68, 0x71, 0xef, 0x88, 0x66, 0xad,
+ 0xa5, 0xb4, 0x5a, 0xf2, 0x01, 0x15, 0x3b, 0x59, 0xd4, 0xdd, 0x6d, 0x24, 0x67,
+ 0x95, 0x2b, 0xd2, 0xb1, 0x75, 0xf1, 0x1b, 0xb9, 0x4e,
+ ],
+ [
+ 0x29, 0x79, 0xe6, 0x0d, 0x8c, 0x0f, 0x5b, 0x4b, 0xad, 0xba, 0x4b, 0xac, 0xea,
+ 0x92, 0x4b, 0x4f, 0x74, 0x74, 0xb9, 0x85, 0xca, 0x84, 0xfa, 0x9e, 0xdd, 0xe0,
+ 0x02, 0x0a, 0x94, 0x22, 0x76, 0xb5, 0x48, 0x3d, 0xd2, 0x97, 0xe2, 0xa4, 0x0c,
+ 0xcd, 0x99, 0x50, 0x3b, 0xe4, 0x51, 0xb8, 0x45, 0x40, 0xc9, 0x88, 0xc7, 0x73,
+ 0xda, 0x78, 0x33, 0x24, 0xf2, 0xf4, 0x4f, 0x87, 0x0c, 0xa2, 0xd0, 0xdf,
+ ]
+ ),
+ test_case!(
+ [
+ 0xc1, 0xe2, 0x99, 0xa7, 0xa2, 0x5b, 0xb9, 0x05, 0x74, 0x3f, 0x50, 0x09, 0xfd,
+ 0x56, 0x25, 0x41, 0x93, 0xdd, 0xa7, 0xe1, 0x67, 0xa5,
+ ],
+ [
+ 0xbd, 0xfb, 0xae, 0x49, 0x43, 0x93, 0xa2, 0xfa, 0xeb, 0xbc, 0x30, 0x10, 0x06,
+ 0x5a, 0x7e, 0x3c, 0x31, 0x0d, 0x8a, 0xf5,
+ ],
+ [
+ 0x25, 0x21, 0x22, 0xe2, 0x0e, 0xfc, 0x1d, 0xbe, 0x89, 0xcd, 0x03, 0xfe, 0x97,
+ 0x2f, 0x19, 0xd6, 0x65, 0x95, 0x65, 0xe6, 0x39, 0x7d, 0x2e, 0x06, 0xea, 0x95,
+ 0xc3, 0xc6, 0x92, 0xe0, 0x66, 0xbe,
+ ],
+ [
+ 0x38, 0x8a, 0x92, 0x99, 0x7c, 0xa3, 0x4e, 0x55, 0xf3, 0xf5, 0x3f, 0x70, 0xff,
+ 0xa6, 0x5d, 0x66, 0xda, 0xeb, 0x1e, 0x27, 0x34, 0xce, 0xd7, 0x21, 0xdc, 0xbc,
+ 0xcd, 0x23, 0x1a, 0x6e, 0xfe, 0x67, 0x1f, 0x36, 0x2f, 0x9f, 0x25, 0xc1, 0xb8,
+ 0x76, 0x7c, 0x05, 0xac, 0x3c, 0xd1, 0xb7, 0x96, 0xd1,
+ ],
+ [
+ 0x9a, 0x28, 0x69, 0x0f, 0x6b, 0xfe, 0x1f, 0x09, 0xc3, 0x09, 0x9e, 0x58, 0x9f,
+ 0x63, 0x83, 0xc7, 0x01, 0xa4, 0xab, 0x7f, 0xbd, 0xcc, 0x64, 0x5e, 0xda, 0xd1,
+ 0x38, 0xdd, 0x3e, 0x72, 0xa6, 0x39, 0xff, 0x8e, 0xcc, 0xa4, 0xa8, 0xe4, 0xd6,
+ 0x98, 0x03, 0x83, 0xb6, 0xec, 0x22, 0x07, 0x7e, 0x54, 0x23, 0x1b, 0x5b, 0x47,
+ 0x0b, 0x2a, 0x17, 0x88, 0x51, 0x04, 0x5d, 0x33, 0xe4, 0xa4, 0xda, 0x36,
+ ]
+ ),
+ test_case!(
+ [
+ 0xf3, 0xcb, 0xac, 0x95, 0xfd, 0x74, 0x21, 0xa8, 0x25, 0x21, 0xe4, 0x4e, 0x2f,
+ 0x4f, 0x11, 0xe2, 0xc1, 0xf6, 0xe2, 0x87, 0xcb, 0x1c, 0xa8,
+ ],
+ [
+ 0xb1, 0x8a, 0x12, 0x63, 0x33, 0x5e, 0xa3, 0xdf, 0x65, 0x6a, 0x38, 0x13, 0xe3,
+ 0xd9, 0x1b, 0x32, 0xc9, 0xe2, 0x59, 0xfe,
+ ],
+ [
+ 0x33, 0x12, 0x28, 0x64, 0x7c, 0xf0, 0x63, 0xf7, 0xc9, 0x45, 0x39, 0x17, 0x18,
+ 0x14, 0xa0, 0x6c, 0xb3, 0xab, 0x85, 0x4f, 0x8c, 0xbd, 0x56, 0xc6, 0x76, 0x31,
+ 0x67, 0x66, 0x39, 0xdc, 0xd5, 0xc4,
+ ],
+ [
+ 0x62, 0xf9, 0xdd, 0x10, 0xfa, 0xf2, 0xbf, 0xa4, 0x13, 0xf2, 0x46, 0xb6, 0x11,
+ 0x88, 0x97, 0x9e, 0x21, 0xef, 0x94, 0x7b, 0x34, 0x73, 0xa3, 0x43, 0x94, 0x3c,
+ 0xc3, 0xcc, 0x3a, 0xe8, 0x93, 0x26, 0xb1, 0xee, 0x51, 0x43, 0xa6, 0x82, 0x77,
+ 0x35, 0x7c, 0x43, 0xff, 0xa5, 0xac, 0x27, 0x97, 0x3e,
+ ],
+ [
+ 0x3d, 0xdf, 0x7a, 0x6b, 0xa5, 0x15, 0xaa, 0x68, 0xc4, 0x2f, 0x3b, 0xce, 0x60,
+ 0x65, 0xde, 0x58, 0x42, 0x03, 0xe0, 0x80, 0x61, 0xc7, 0x87, 0xb1, 0x2c, 0xbd,
+ 0xd2, 0x61, 0x06, 0x6a, 0x04, 0xd4, 0x2c, 0xa9, 0x4a, 0xc0, 0x84, 0x3b, 0xfa,
+ 0xe5, 0x83, 0x19, 0x8f, 0x4c, 0x1f, 0x69, 0x6b, 0xf1, 0xbc, 0x2e, 0x9f, 0x4c,
+ 0xdf, 0xc9, 0xf6, 0x9c, 0x2a, 0xd2, 0x80, 0x5b, 0xd2, 0x4f, 0xf9, 0x14,
+ ]
+ ),
+ test_case!(
+ [
+ 0x1a, 0x5e, 0x44, 0xf6, 0x69, 0x86, 0xbf, 0x9d, 0x21, 0x08, 0xd8, 0x6e, 0xd2,
+ 0x7c, 0xc4, 0x1c, 0xa7, 0x9e, 0xc9, 0x7e, 0x06, 0x61, 0x7f, 0x79,
+ ],
+ [
+ 0xa7, 0x21, 0x10, 0x5f, 0xe3, 0x34, 0xe3, 0xe7, 0x21, 0x65, 0x66, 0xd7, 0xe0,
+ 0x8b, 0x32, 0xd5, 0x86, 0x80, 0x90, 0x85,
+ ],
+ [
+ 0xa5, 0xe2, 0x8a, 0xc0, 0x37, 0xb9, 0x04, 0x8b, 0xd5, 0x75, 0x29, 0x95, 0xfb,
+ 0x18, 0x8d, 0x64, 0xa2, 0xc5, 0x39, 0x80, 0x57, 0x57, 0x10, 0x90, 0x1e, 0x5e,
+ 0x90, 0xaa, 0x95, 0x8c, 0xa4, 0x9a,
+ ],
+ [
+ 0xd4, 0x5f, 0x14, 0xef, 0xec, 0x90, 0x63, 0x39, 0x71, 0xa1, 0x7e, 0xc0, 0xfe,
+ 0x00, 0x7a, 0xde, 0xb6, 0x52, 0x27, 0x3d, 0xea, 0x63, 0x82, 0xdb, 0x27, 0x78,
+ 0xce, 0x1a, 0x1e, 0xdb, 0x29, 0x1d, 0xaf, 0xa2, 0x64, 0xee, 0x2d, 0x42, 0x8d,
+ 0x80, 0xb4, 0x6a, 0x3b, 0x8a, 0x96, 0x93, 0x24, 0xfa,
+ ],
+ [
+ 0x11, 0xac, 0xa6, 0x8c, 0x19, 0xa3, 0xa9, 0xbe, 0xea, 0xb6, 0xc0, 0x8e, 0x7c,
+ 0x5f, 0x33, 0xf5, 0xe8, 0x0d, 0xc0, 0x3c, 0x16, 0x27, 0xad, 0x23, 0xdf, 0x24,
+ 0x0b, 0xeb, 0xb6, 0x1e, 0x41, 0xae, 0x07, 0xdc, 0xa9, 0xeb, 0x10, 0xff, 0x3c,
+ 0xfd, 0xab, 0xcf, 0xac, 0x1c, 0xbe, 0x29, 0xbc, 0xf3, 0x4f, 0x53, 0x9c, 0x20,
+ 0x9a, 0xb6, 0x58, 0x98, 0x3a, 0xa5, 0x44, 0xec, 0x2f, 0xc9, 0xd0, 0x0a,
+ ]
+ ),
+ test_case!(
+ [
+ 0x4f, 0xe1, 0xfa, 0x85, 0x10, 0xf8, 0x1e, 0x6a, 0xea, 0xc0, 0xb1, 0xd7, 0xc8,
+ 0x83, 0x51, 0x99, 0x6e, 0x62, 0xb7, 0x39, 0x2a, 0x20, 0x10, 0xac, 0xb9,
+ ],
+ [
+ 0xff, 0x2e, 0x33, 0x8f, 0x1e, 0x06, 0x4e, 0x90, 0xd6, 0x30, 0x38, 0x81, 0x55,
+ 0x35, 0x48, 0x71, 0x9f, 0xd5, 0x72, 0x9a,
+ ],
+ [
+ 0x71, 0x38, 0x91, 0x14, 0x63, 0x80, 0xaf, 0x21, 0x0a, 0x44, 0x9f, 0xf4, 0x8e,
+ 0x6f, 0x28, 0xbf, 0x72, 0xec, 0x85, 0x17, 0x4d, 0x63, 0xc7, 0x99, 0xd3, 0xb5,
+ 0x35, 0xc0, 0x84, 0xb2, 0x39, 0xd1,
+ ],
+ [
+ 0x7e, 0x7b, 0x46, 0xa4, 0xd4, 0x08, 0x18, 0xb9, 0x2e, 0xbd, 0x41, 0x4d, 0x19,
+ 0xb6, 0xe1, 0x57, 0x95, 0xd5, 0x4f, 0x28, 0x92, 0x40, 0xcc, 0x8c, 0x32, 0x78,
+ 0xbe, 0x59, 0xc3, 0x72, 0x9b, 0x75, 0xcf, 0xbe, 0xfa, 0x37, 0x61, 0xa0, 0x3e,
+ 0xd6, 0x24, 0x30, 0xeb, 0xa1, 0x32, 0x30, 0xd4, 0x90,
+ ],
+ [
+ 0x51, 0x6a, 0xd6, 0x0e, 0xea, 0xbb, 0x6d, 0x9e, 0xf3, 0x64, 0x9a, 0x2c, 0xe9,
+ 0xdc, 0x29, 0x5e, 0x7a, 0x5d, 0x21, 0xa2, 0x5c, 0x11, 0x56, 0xc1, 0x74, 0xae,
+ 0x9c, 0xb7, 0x8c, 0x28, 0x11, 0xa4, 0x5d, 0x8b, 0x55, 0xd8, 0xd3, 0x61, 0xb7,
+ 0x9f, 0x18, 0xc5, 0x55, 0xe1, 0x5b, 0x80, 0x15, 0x4b, 0x51, 0x15, 0x93, 0x38,
+ 0x02, 0xd8, 0x45, 0x2f, 0x86, 0x3a, 0x4d, 0xb8, 0xa3, 0x71, 0xa9, 0x49,
+ ]
+ ),
+ test_case!(
+ [
+ 0xa8, 0x08, 0x67, 0x1e, 0x27, 0x35, 0x1e, 0x56, 0x2d, 0x57, 0xa5, 0xce, 0xa8,
+ 0x5b, 0x7e, 0x7b, 0xb2, 0x2c, 0x85, 0x1b, 0x2e, 0xc5, 0x44, 0x65, 0x1e, 0x87,
+ ],
+ [
+ 0xe0, 0x44, 0xb2, 0x0a, 0x1f, 0x0b, 0x28, 0xe4, 0x30, 0xc9, 0x79, 0xec, 0x3e,
+ 0xf9, 0x5f, 0x27, 0xb5, 0x7d, 0xc6, 0x22,
+ ],
+ [
+ 0xf8, 0x07, 0x78, 0xc1, 0x7f, 0x0b, 0x44, 0x7b, 0xe7, 0xba, 0x56, 0x29, 0x78,
+ 0xdb, 0xb6, 0xde, 0x07, 0x09, 0x4a, 0x9a, 0x3c, 0x84, 0x71, 0x8e, 0xde, 0x0e,
+ 0x67, 0x85, 0xbb, 0xf0, 0x87, 0xfb,
+ ],
+ [
+ 0x6b, 0xd2, 0x50, 0xa8, 0x80, 0xc1, 0x74, 0xa0, 0x2c, 0xd8, 0x11, 0x29, 0x33,
+ 0x11, 0x7a, 0x37, 0x19, 0x39, 0x7a, 0x30, 0x01, 0xe8, 0xbc, 0x85, 0x0f, 0x07,
+ 0xb5, 0xcd, 0xb4, 0x08, 0x81, 0xc4, 0x84, 0x2b, 0x83, 0x36, 0xaa, 0x48, 0xf0,
+ 0x1c, 0x38, 0x1f, 0x2a, 0x35, 0x45, 0x28, 0x77, 0x10,
+ ],
+ [
+ 0xf7, 0x98, 0xa7, 0x6b, 0xb6, 0x16, 0xf2, 0xec, 0xa0, 0x9a, 0xe2, 0x2b, 0xf4,
+ 0x79, 0x45, 0xfe, 0x46, 0x3b, 0x91, 0x12, 0x48, 0xc5, 0xa3, 0xcb, 0xe6, 0x14,
+ 0xfe, 0x6b, 0x5b, 0x30, 0xd1, 0x5a, 0x3a, 0x85, 0x58, 0xa2, 0x95, 0x4c, 0x04,
+ 0x09, 0x69, 0x51, 0xe1, 0x11, 0x09, 0xcc, 0x79, 0xea, 0x4d, 0x4f, 0x07, 0x38,
+ 0x9c, 0x58, 0x4e, 0x00, 0x54, 0xfd, 0x2f, 0xb2, 0xa4, 0x5b, 0x98, 0xc2,
+ ]
+ ),
+ test_case!(
+ [
+ 0x33, 0xb8, 0xf5, 0xfd, 0xb6, 0x39, 0x2c, 0xea, 0x31, 0xd8, 0x33, 0x36, 0xf8,
+ 0x84, 0xfc, 0x23, 0x16, 0xa3, 0x4e, 0xe4, 0xf8, 0x21, 0xb5, 0x55, 0xa8, 0x83,
+ 0x8d,
+ ],
+ [
+ 0xb7, 0x2c, 0x8f, 0x31, 0xd5, 0xed, 0x7b, 0x75, 0x37, 0x72, 0x47, 0xc2, 0x6d,
+ 0x66, 0x96, 0xb6, 0x4c, 0xc4, 0x0a, 0xfa,
+ ],
+ [
+ 0xca, 0x6e, 0xaa, 0xc3, 0x73, 0x5b, 0x62, 0x4d, 0xa5, 0x12, 0x80, 0x92, 0x92,
+ 0x74, 0xcf, 0x53, 0x44, 0x8b, 0x05, 0xeb, 0x27, 0x40, 0xda, 0xe7, 0xf6, 0x9b,
+ 0x59, 0xa3, 0xca, 0x2e, 0xe4, 0x8a,
+ ],
+ [
+ 0xad, 0x90, 0xe4, 0x59, 0x3f, 0x71, 0x8a, 0xc3, 0x77, 0xd0, 0x55, 0xc2, 0xe5,
+ 0x4e, 0x3d, 0x96, 0x6f, 0xe3, 0xcf, 0x0f, 0xae, 0x79, 0xbc, 0xaa, 0x11, 0x74,
+ 0x46, 0xcd, 0x2c, 0x1b, 0xdf, 0xbf, 0xd6, 0x5f, 0x05, 0xea, 0x64, 0xae, 0xc7,
+ 0xd3, 0xbe, 0x55, 0xb9, 0xad, 0xc3, 0x22, 0x4a, 0xa3,
+ ],
+ [
+ 0x4d, 0x60, 0x6c, 0x85, 0xbc, 0x45, 0xdf, 0xf1, 0xc1, 0xb6, 0xd2, 0x97, 0x09,
+ 0x7e, 0xb9, 0x13, 0x16, 0xeb, 0x27, 0x20, 0xeb, 0xd1, 0x9a, 0xf4, 0xad, 0x52,
+ 0x80, 0xde, 0xdd, 0x2b, 0xce, 0x6f, 0x29, 0xbc, 0x9b, 0x65, 0xd1, 0x64, 0xf1,
+ 0x71, 0x77, 0x6e, 0x36, 0x76, 0xbb, 0x51, 0xc0, 0xcc, 0x79, 0x2e, 0xee, 0xe0,
+ 0x7b, 0x47, 0x11, 0x75, 0xa0, 0x44, 0x36, 0x75, 0x4a, 0xd5, 0x2a, 0xc5,
+ ]
+ ),
+ test_case!(
+ [
+ 0xfb, 0x75, 0xd7, 0x72, 0x25, 0xfa, 0xd8, 0x4b, 0x98, 0x3d, 0x0f, 0xcc, 0xf9,
+ 0x8d, 0xfd, 0xbf, 0x35, 0x97, 0x3e, 0xb5, 0xbb, 0xf0, 0xf6, 0x1a, 0xa3, 0x2b,
+ 0x22, 0x67,
+ ],
+ [
+ 0xa9, 0xb6, 0x45, 0xdf, 0x54, 0x3b, 0x53, 0xd6, 0x92, 0x3f, 0x32, 0x80, 0xae,
+ 0x7c, 0x5f, 0x8b, 0xa5, 0x8a, 0x62, 0x1d,
+ ],
+ [
+ 0x1d, 0x78, 0xba, 0x8f, 0x84, 0xa6, 0x36, 0xf0, 0x1e, 0xf4, 0x2a, 0x6a, 0x67,
+ 0xec, 0x22, 0x4a, 0x59, 0xf2, 0x04, 0x5d, 0x65, 0xda, 0x35, 0x74, 0x91, 0x3f,
+ 0x04, 0xbc, 0x9c, 0x25, 0x55, 0xf4,
+ ],
+ [
+ 0xfa, 0xd9, 0x9f, 0x14, 0x94, 0xf5, 0xa9, 0x8e, 0x0d, 0x21, 0xb4, 0xd1, 0x6c,
+ 0x28, 0x82, 0x2c, 0x71, 0x67, 0xc7, 0x31, 0xe1, 0xb3, 0x48, 0xec, 0xa5, 0xe1,
+ 0x36, 0xdb, 0x15, 0x06, 0x83, 0x30, 0x67, 0xd3, 0x3e, 0x29, 0x57, 0xe9, 0xe3,
+ 0x8f, 0xae, 0x75, 0xbc, 0x91, 0x8e, 0x08, 0xc9, 0xe2,
+ ],
+ [
+ 0x37, 0x50, 0x62, 0x23, 0x99, 0x49, 0x37, 0x64, 0xbe, 0xc3, 0xe6, 0x23, 0xaf,
+ 0x9d, 0x9a, 0xc2, 0x48, 0x0d, 0x6d, 0x35, 0x3a, 0x0e, 0x2d, 0x29, 0xae, 0x06,
+ 0x2f, 0x2e, 0x51, 0xeb, 0xaf, 0xea, 0x08, 0x8e, 0x6c, 0xde, 0x9b, 0x10, 0x8d,
+ 0xee, 0xf3, 0xfa, 0xbc, 0xc3, 0x22, 0xb7, 0xec, 0x93, 0x18, 0x0a, 0xaa, 0x63,
+ 0xd8, 0xe1, 0x18, 0x03, 0xe5, 0x67, 0xab, 0x24, 0xd3, 0x42, 0x5f, 0x64,
+ ]
+ ),
+ test_case!(
+ [
+ 0xca, 0xf3, 0x50, 0x61, 0x4a, 0x0e, 0xf6, 0xcb, 0x1e, 0x8c, 0x8c, 0x31, 0xa9,
+ 0x4d, 0x85, 0x6a, 0xef, 0x80, 0x94, 0x1f, 0x56, 0x24, 0xde, 0x64, 0x44, 0x14,
+ 0x8a, 0x51, 0x65,
+ ],
+ [
+ 0x53, 0xc9, 0x5a, 0x79, 0xf8, 0x1c, 0x7f, 0xb3, 0x3b, 0xf6, 0x6a, 0x62, 0xee,
+ 0x03, 0xd5, 0xc3, 0x69, 0x2b, 0x87, 0x00,
+ ],
+ [
+ 0xbd, 0xe7, 0xf3, 0xc4, 0xe9, 0xff, 0xc1, 0x80, 0xb8, 0xa1, 0x9f, 0x5e, 0xb5,
+ 0x23, 0xdd, 0x31, 0xaa, 0x50, 0x27, 0xaf, 0x27, 0x02, 0x5d, 0xc1, 0xb1, 0x56,
+ 0x11, 0x02, 0xce, 0x85, 0xdb, 0x00,
+ ],
+ [
+ 0x1e, 0x38, 0x5d, 0x8b, 0x67, 0x0a, 0x21, 0xf5, 0x7d, 0xb7, 0x75, 0x4a, 0xa1,
+ 0x94, 0x3c, 0xd8, 0xfb, 0x51, 0xf1, 0x5f, 0x01, 0xd6, 0x88, 0x45, 0x4a, 0x26,
+ 0x43, 0xb7, 0xe7, 0x40, 0xb1, 0xf9, 0xa7, 0xb6, 0x41, 0x1c, 0x45, 0xed, 0x68,
+ 0x07, 0xf6, 0xc2, 0x9f, 0xb3, 0x5a, 0x2e, 0x23, 0x1d,
+ ],
+ [
+ 0x43, 0xb3, 0xde, 0xb1, 0x2d, 0x5c, 0x96, 0x29, 0x5a, 0x80, 0x57, 0xb6, 0x0d,
+ 0x8c, 0x7b, 0x03, 0x86, 0xd3, 0x4b, 0x87, 0x9d, 0xe5, 0xd0, 0xa5, 0xa9, 0x78,
+ 0xa8, 0x2a, 0x6a, 0x7c, 0x4f, 0xd7, 0x69, 0x18, 0x32, 0x72, 0x72, 0x8a, 0xa5,
+ 0xc5, 0x90, 0x1f, 0xf9, 0x1e, 0x72, 0xbb, 0x38, 0x81, 0x66, 0x6e, 0xd3, 0x8d,
+ 0x22, 0x44, 0x35, 0x00, 0x27, 0xe7, 0xb1, 0x0d, 0x44, 0x00, 0x02, 0x18,
+ ]
+ ),
+ test_case!(
+ [
+ 0x45, 0xc2, 0x69, 0x41, 0xac, 0x58, 0xb9, 0xa2, 0x6f, 0xc3, 0xe1, 0x2b, 0x47,
+ 0x1e, 0x03, 0x3c, 0x93, 0x43, 0x12, 0xd6, 0xa5, 0xf9, 0x22, 0x37, 0xfc, 0xfa,
+ 0xaf, 0xf2, 0xfc, 0x81,
+ ],
+ [
+ 0xee, 0x02, 0xd8, 0x1e, 0xb0, 0x28, 0x38, 0x9f, 0x68, 0x26, 0x61, 0xa9, 0x5b,
+ 0x7d, 0xc4, 0x47, 0x24, 0x24, 0xd7, 0x9b,
+ ],
+ [
+ 0xcd, 0x4e, 0xdd, 0x84, 0x5f, 0x65, 0xb5, 0xd5, 0x34, 0xff, 0xaf, 0x55, 0x30,
+ 0x51, 0xdb, 0x44, 0xfd, 0xf4, 0x07, 0x8d, 0x3a, 0xce, 0xa3, 0xc3, 0xa1, 0x6c,
+ 0x65, 0x06, 0xd7, 0x79, 0x88, 0xed,
+ ],
+ [
+ 0xe2, 0xcb, 0xf7, 0xe0, 0xab, 0x29, 0xe8, 0xac, 0x70, 0x73, 0x4a, 0xfb, 0xfb,
+ 0x87, 0xc7, 0x6b, 0xfa, 0x06, 0x87, 0xba, 0x28, 0x04, 0xd6, 0x77, 0x6f, 0x39,
+ 0xe4, 0x21, 0x90, 0x7c, 0xf1, 0x28, 0x9b, 0x76, 0x68, 0x5b, 0xdb, 0x66, 0x64,
+ 0x06, 0x4f, 0x6c, 0x81, 0x45, 0xbc, 0x63, 0xa7, 0x53,
+ ],
+ [
+ 0x73, 0xed, 0x28, 0x11, 0xa9, 0xb5, 0xd8, 0xc3, 0x9c, 0x9f, 0xe0, 0x1b, 0x32,
+ 0xb1, 0x43, 0xe6, 0x99, 0x0e, 0x79, 0x56, 0xe8, 0x83, 0x57, 0xd3, 0xcd, 0xad,
+ 0x14, 0x4f, 0xcd, 0x1b, 0x01, 0x82, 0x47, 0x27, 0x01, 0xee, 0x3d, 0x50, 0x90,
+ 0x17, 0x93, 0xf3, 0x5e, 0x02, 0x8e, 0x1c, 0xa6, 0xf7, 0xf1, 0xfe, 0x0e, 0x19,
+ 0x9c, 0x19, 0x45, 0xc1, 0x51, 0xe7, 0x18, 0xaf, 0x6a, 0x80, 0x2b, 0x84,
+ ]
+ ),
+ test_case!(
+ [
+ 0x32, 0xac, 0x3d, 0xbc, 0x99, 0x0d, 0x3d, 0xc2, 0xba, 0xf6, 0xee, 0xcc, 0x78,
+ 0x0f, 0x64, 0xa2, 0x03, 0x08, 0x08, 0xcd, 0x57, 0x00, 0x19, 0x9f, 0xa1, 0xa9,
+ 0xf9, 0x0d, 0x67, 0xd0, 0x00,
+ ],
+ [
+ 0xba, 0x29, 0x75, 0x9d, 0xb2, 0x89, 0xe4, 0x65, 0x20, 0x18, 0xe0, 0x77, 0xf8,
+ 0x59, 0x94, 0x11, 0xa8, 0x47, 0xbb, 0x2f,
+ ],
+ [
+ 0xf0, 0x88, 0x03, 0xc7, 0xa1, 0xf5, 0x13, 0x04, 0x3f, 0x01, 0xd1, 0xca, 0x65,
+ 0x86, 0x98, 0x09, 0xa8, 0xd4, 0xa2, 0x80, 0x12, 0x7a, 0x0c, 0xb6, 0x02, 0xe8,
+ 0xc9, 0x56, 0x1f, 0xc6, 0xec, 0x7a,
+ ],
+ [
+ 0xb3, 0x27, 0xc8, 0x0b, 0x23, 0xb0, 0xad, 0xae, 0xea, 0x14, 0xa2, 0xf2, 0x0e,
+ 0x1b, 0xab, 0xc3, 0xd2, 0xac, 0x56, 0xfe, 0x14, 0xf8, 0xce, 0x73, 0xac, 0x12,
+ 0xe6, 0x7b, 0xc3, 0x1a, 0x58, 0x19, 0xd0, 0x87, 0x15, 0xa2, 0xc9, 0x9e, 0x3c,
+ 0x84, 0x7d, 0x50, 0xe9, 0x41, 0x3d, 0x74, 0x1c, 0x13,
+ ],
+ [
+ 0x2e, 0x36, 0xac, 0xe8, 0x14, 0xd6, 0x9e, 0xf8, 0x04, 0xe0, 0xfb, 0x36, 0x23,
+ 0xb8, 0xb5, 0x36, 0x29, 0xc3, 0x16, 0x33, 0x8a, 0x3d, 0xa7, 0x33, 0xeb, 0x60,
+ 0x09, 0xa2, 0x83, 0xf9, 0x69, 0x42, 0xef, 0xd6, 0x77, 0x82, 0x7d, 0xef, 0x45,
+ 0x87, 0xdd, 0x55, 0x37, 0x21, 0xa2, 0x9f, 0x71, 0xa8, 0xde, 0xcd, 0x07, 0x07,
+ 0xf3, 0xf0, 0x16, 0xf6, 0x95, 0x25, 0x30, 0x26, 0xa4, 0x73, 0xe3, 0x04,
+ ]
+ ),
+ test_case!(
+ [
+ 0xec, 0x06, 0x20, 0xc1, 0xb7, 0xb7, 0xbb, 0xc8, 0x00, 0x0e, 0x54, 0xb5, 0xbb,
+ 0x7e, 0x0b, 0xdf, 0xb5, 0x97, 0xf3, 0xa7, 0x43, 0x8e, 0xd0, 0xf0, 0x9a, 0xba,
+ 0x48, 0x35, 0xa4, 0xa0, 0xf5, 0xee,
+ ],
+ [
+ 0xf6, 0xd8, 0xcb, 0x20, 0xa3, 0x08, 0x65, 0xdb, 0x4d, 0x27, 0xe7, 0x24, 0xa5,
+ 0x9c, 0x8d, 0x29, 0xbf, 0xc7, 0x49, 0x4c,
+ ],
+ [
+ 0x78, 0xf9, 0x5b, 0xec, 0x7a, 0x79, 0x03, 0x12, 0xdd, 0x0d, 0xb8, 0x98, 0xca,
+ 0xb7, 0x8d, 0xbf, 0x1c, 0x65, 0x69, 0x41, 0xeb, 0x3c, 0xc2, 0x33, 0x84, 0x43,
+ 0xb0, 0xc0, 0xed, 0x39, 0x50, 0x57,
+ ],
+ [
+ 0xf7, 0xc9, 0x4b, 0xd8, 0x2d, 0xe8, 0xcf, 0x76, 0x30, 0xd0, 0x87, 0x33, 0xfe,
+ 0x60, 0x7d, 0x54, 0xee, 0x26, 0xb0, 0xd9, 0x87, 0xbf, 0x5b, 0x73, 0xc6, 0x43,
+ 0x51, 0xa4, 0x15, 0x02, 0x35, 0x13, 0x6e, 0x4e, 0x8a, 0xa0, 0x48, 0x0c, 0x7f,
+ 0x17, 0xc3, 0x58, 0xa0, 0xdc, 0xf7, 0x13, 0x59, 0x38,
+ ],
+ [
+ 0xee, 0xb7, 0xc5, 0x97, 0x81, 0x73, 0x94, 0xfe, 0x5a, 0xdd, 0x0c, 0xde, 0x51,
+ 0x16, 0xf8, 0x5d, 0x4a, 0x16, 0x46, 0x73, 0x78, 0xbb, 0x1a, 0x8e, 0x42, 0xe7,
+ 0x1a, 0x74, 0xbf, 0x26, 0xc3, 0x00, 0xc3, 0x62, 0xbd, 0x37, 0xca, 0x16, 0x74,
+ 0x5f, 0xea, 0x97, 0x55, 0x2c, 0x2f, 0xf5, 0xd2, 0xbe, 0x7c, 0x32, 0x15, 0xdf,
+ 0xa5, 0x6f, 0xed, 0x38, 0x91, 0x47, 0xf7, 0xaf, 0x17, 0xee, 0x78, 0x44,
+ ]
+ ),
+ test_case!(
+ [
+ 0xd8, 0x3f, 0x48, 0x02, 0x79, 0x3e, 0x53, 0x79, 0xe1, 0x0c, 0x90, 0x2a, 0x86,
+ 0x76, 0xe3, 0xb8, 0x82, 0xdf, 0x20, 0xd4, 0xd8, 0xf1, 0x21, 0x3f, 0x87, 0xbd,
+ 0x03, 0xf7, 0x6d, 0xf2, 0x4b, 0x32, 0xee,
+ ],
+ [
+ 0x0c, 0xb3, 0x00, 0xca, 0x40, 0x5e, 0x61, 0x50, 0xba, 0x43, 0xf9, 0x12, 0x45,
+ 0xfd, 0x0c, 0x83, 0xe7, 0x74, 0x09, 0x10,
+ ],
+ [
+ 0x1f, 0x35, 0x61, 0x55, 0xad, 0x41, 0x86, 0x93, 0x39, 0xb9, 0x49, 0x94, 0xcd,
+ 0xac, 0x3f, 0x16, 0x82, 0xad, 0x00, 0xf5, 0x38, 0x39, 0x29, 0x26, 0x13, 0x2d,
+ 0x57, 0xa4, 0x90, 0x83, 0x0a, 0x44,
+ ],
+ [
+ 0x01, 0x70, 0x2c, 0x07, 0x01, 0xfa, 0xa2, 0x73, 0x3f, 0xb2, 0xbf, 0xfa, 0x14,
+ 0xaf, 0x95, 0x1c, 0xbc, 0x5c, 0x2d, 0xa0, 0x03, 0xc3, 0xd5, 0x6e, 0x42, 0x5e,
+ 0x41, 0xf2, 0xa2, 0x12, 0x74, 0xc7, 0xa0, 0xa6, 0x60, 0x68, 0x13, 0x42, 0xec,
+ 0xfc, 0x4f, 0x95, 0x78, 0xca, 0x73, 0x34, 0x88, 0x72,
+ ],
+ [
+ 0x83, 0x5e, 0xd9, 0x1f, 0xcc, 0x9a, 0x86, 0xa1, 0x4c, 0x44, 0x84, 0xa3, 0x56,
+ 0x54, 0x52, 0x9e, 0xde, 0x82, 0xf7, 0xc3, 0x9f, 0xd6, 0x78, 0xd3, 0x58, 0xa4,
+ 0x2a, 0x23, 0x0a, 0xce, 0x36, 0x22, 0xdd, 0x86, 0x46, 0x4c, 0x72, 0x62, 0x2f,
+ 0x29, 0xe6, 0x2b, 0x2a, 0xbc, 0xa1, 0x61, 0x21, 0x44, 0x95, 0x7e, 0x7a, 0x38,
+ 0x29, 0x57, 0x93, 0xe4, 0x1f, 0xe1, 0x77, 0x8d, 0x06, 0x65, 0xe5, 0x1f,
+ ]
+ ),
+ test_case!(
+ [
+ 0xf4, 0xeb, 0xb5, 0x70, 0xdc, 0x36, 0xf6, 0x25, 0xa8, 0xe8, 0xae, 0x40, 0x7a,
+ 0x39, 0xdf, 0x0d, 0xc0, 0xd7, 0xf9, 0x6e, 0x9e, 0x24, 0x97, 0x5f, 0x84, 0x78,
+ 0xd7, 0x31, 0x18, 0xfa, 0x13, 0xd5, 0x1b, 0x93,
+ ],
+ [
+ 0x3f, 0xd8, 0xc3, 0x1d, 0x6b, 0x20, 0x2a, 0xdb, 0x3b, 0xac, 0x6b, 0x3a, 0x50,
+ 0x05, 0x54, 0x7f, 0x1c, 0x8e, 0x3c, 0x2e,
+ ],
+ [
+ 0x94, 0x20, 0x5d, 0xbf, 0xd0, 0x85, 0x38, 0x75, 0x18, 0x08, 0xb2, 0x2f, 0x33,
+ 0x3a, 0xbc, 0xca, 0xf1, 0xa9, 0xde, 0x86, 0x9d, 0x4f, 0xa9, 0x8d, 0x2c, 0x60,
+ 0x0c, 0x8c, 0xa2, 0xa9, 0xce, 0x8b,
+ ],
+ [
+ 0xcf, 0x28, 0xe1, 0x59, 0xb2, 0xd5, 0xea, 0x81, 0xd6, 0x9f, 0xb1, 0x4a, 0xba,
+ 0xe3, 0xd4, 0x48, 0x5a, 0x4f, 0x49, 0xdd, 0xdc, 0x14, 0x38, 0x45, 0xab, 0xb2,
+ 0x9e, 0x2b, 0x41, 0x86, 0x24, 0x77, 0x87, 0xee, 0xa3, 0xfc, 0xab, 0xdb, 0xf3,
+ 0xea, 0xee, 0x09, 0x53, 0xb6, 0xc3, 0x64, 0x46, 0xba,
+ ],
+ [
+ 0x02, 0xce, 0xe5, 0x88, 0xb2, 0x09, 0x6d, 0xd5, 0xf5, 0xf4, 0xa4, 0xe4, 0x7a,
+ 0x48, 0x20, 0xa3, 0xde, 0x81, 0x6e, 0x8d, 0xa5, 0x1e, 0xf0, 0x6d, 0x0d, 0x1c,
+ 0x0b, 0x0d, 0x74, 0xca, 0x44, 0x29, 0xc7, 0xf2, 0x39, 0x8c, 0x83, 0xad, 0xb3,
+ 0x15, 0x6a, 0xdf, 0x49, 0xc2, 0xfa, 0x08, 0x10, 0x8e, 0x38, 0xd2, 0xce, 0x32,
+ 0xae, 0x67, 0xc0, 0xa2, 0xfa, 0x08, 0xd4, 0xd1, 0xb7, 0x36, 0xbd, 0x96,
+ ]
+ ),
+ test_case!(
+ [
+ 0x90, 0x10, 0x96, 0xca, 0x77, 0x56, 0x7d, 0x1e, 0xa2, 0x93, 0xe5, 0x15, 0x7d,
+ 0xcd, 0x10, 0x0b, 0x03, 0x9c, 0x8c, 0x01, 0xbc, 0xde, 0xbf, 0x80, 0xc5, 0xe7,
+ 0xf3, 0xb2, 0x04, 0x2d, 0x6d, 0x26, 0x70, 0x28, 0xdf,
+ ],
+ [
+ 0xec, 0x2b, 0x0c, 0x5c, 0xfc, 0xe2, 0xb1, 0xc3, 0xf8, 0x03, 0x3f, 0x37, 0x4d,
+ 0x88, 0x48, 0xa9, 0xe0, 0xa8, 0x22, 0x7c,
+ ],
+ [
+ 0x28, 0x82, 0x80, 0x32, 0x60, 0xc9, 0x39, 0xf8, 0x28, 0x43, 0x41, 0xa1, 0xd8,
+ 0x3a, 0x5e, 0x2a, 0x60, 0x4d, 0x8a, 0xd1, 0x7a, 0x26, 0x5c, 0x60, 0x24, 0xd9,
+ 0x84, 0x14, 0xf5, 0x00, 0x55, 0xe3,
+ ],
+ [
+ 0x5e, 0x3a, 0xab, 0x06, 0x1f, 0x57, 0x34, 0x75, 0xa9, 0x0d, 0x07, 0x26, 0x5c,
+ 0xdc, 0x55, 0xdb, 0x75, 0x1f, 0x5e, 0x20, 0x00, 0x2b, 0x9e, 0x13, 0x35, 0x91,
+ 0x58, 0x12, 0xbf, 0x9b, 0xea, 0x77, 0x41, 0x82, 0xd2, 0x1b, 0x69, 0xec, 0xce,
+ 0xb0, 0xdc, 0x83, 0x5b, 0x66, 0x0a, 0x32, 0xbd, 0xda,
+ ],
+ [
+ 0x20, 0xac, 0x92, 0x38, 0xb4, 0x52, 0xe2, 0x62, 0xf9, 0x2f, 0xd3, 0x65, 0x6e,
+ 0xe2, 0x33, 0x12, 0xf2, 0x2e, 0x09, 0xc7, 0x66, 0x3a, 0xa2, 0xbf, 0x89, 0x21,
+ 0x88, 0x50, 0x8a, 0xf1, 0xaf, 0xd8, 0x91, 0x00, 0x95, 0x07, 0x0e, 0x8a, 0x5e,
+ 0xd7, 0xaa, 0x7c, 0x04, 0x2f, 0x69, 0x51, 0x83, 0x97, 0xa6, 0xb3, 0x56, 0xcf,
+ 0x1e, 0x5c, 0xe3, 0xc6, 0x0e, 0x06, 0xab, 0x8e, 0x0b, 0xcb, 0xb0, 0x0e,
+ ]
+ ),
+ test_case!(
+ [
+ 0xda, 0x0b, 0xa3, 0x35, 0x62, 0x5e, 0x26, 0x80, 0x1a, 0x5f, 0xb9, 0xa8, 0x5e,
+ 0xb9, 0xcd, 0x61, 0x3e, 0x67, 0xbc, 0x21, 0xb9, 0xf0, 0x51, 0x5a, 0x03, 0x22,
+ 0x56, 0xd5, 0x6c, 0x04, 0xd0, 0x1b, 0xfb, 0xf0, 0x34, 0x95,
+ ],
+ [
+ 0xa2, 0xaf, 0x27, 0x7c, 0x93, 0x4c, 0x57, 0xaa, 0x09, 0xff, 0xb4, 0xdb, 0x21,
+ 0x22, 0x7a, 0xe8, 0x03, 0x41, 0x6e, 0x30,
+ ],
+ [
+ 0x72, 0xd7, 0xa9, 0xaf, 0xde, 0xab, 0x9a, 0x4d, 0xd3, 0xc4, 0x1e, 0x6c, 0xbd,
+ 0xd3, 0x9a, 0xa4, 0x85, 0x47, 0xc6, 0xfa, 0xac, 0x7b, 0x70, 0x21, 0x53, 0xa4,
+ 0xa1, 0x89, 0xe6, 0x11, 0x8a, 0x04,
+ ],
+ [
+ 0x6c, 0x19, 0xd6, 0x8c, 0x72, 0xb4, 0x6d, 0x1b, 0x2d, 0x13, 0x16, 0x7a, 0x84,
+ 0x5b, 0x2f, 0x41, 0x24, 0xcd, 0x87, 0x0e, 0xab, 0x61, 0xfb, 0x0c, 0x37, 0xa2,
+ 0x5b, 0x9b, 0x6c, 0x75, 0x92, 0xfb, 0xcf, 0x51, 0xbf, 0xda, 0x9d, 0x3d, 0xce,
+ 0x06, 0xd9, 0xaf, 0x33, 0xba, 0x87, 0x93, 0x5b, 0x9b,
+ ],
+ [
+ 0x49, 0xbd, 0x64, 0x1d, 0x17, 0xc2, 0xa5, 0x03, 0xfe, 0xf7, 0xda, 0xf0, 0x47,
+ 0x99, 0xcc, 0x35, 0x67, 0xe3, 0x36, 0x26, 0x8f, 0xde, 0x21, 0x45, 0xf4, 0x4d,
+ 0xa0, 0xd1, 0x44, 0xae, 0x49, 0xd6, 0x41, 0x28, 0xb4, 0xef, 0x8c, 0x2a, 0xd1,
+ 0xfe, 0x1d, 0x02, 0x63, 0x8c, 0x82, 0x3c, 0xda, 0x89, 0x38, 0x4a, 0xbc, 0xdc,
+ 0x1b, 0xe2, 0x97, 0xed, 0x36, 0x2c, 0x0c, 0x31, 0x6a, 0xaa, 0x6e, 0x4e,
+ ]
+ ),
+ test_case!(
+ [
+ 0x67, 0x67, 0xf6, 0xd1, 0xc8, 0xec, 0xe7, 0x31, 0xdb, 0x00, 0xff, 0x8a, 0xdf,
+ 0x34, 0x8e, 0xc4, 0xa5, 0x79, 0x86, 0x1d, 0xa8, 0x88, 0x7e, 0xcb, 0xb0, 0xca,
+ 0x6b, 0x04, 0x72, 0xfe, 0xe6, 0xb2, 0x5a, 0x66, 0x29, 0xcc, 0x38,
+ ],
+ [
+ 0x37, 0x65, 0xe4, 0xf5, 0xe2, 0x05, 0x97, 0x40, 0x04, 0xa9, 0x52, 0x50, 0x2e,
+ 0x74, 0xf6, 0xec, 0xd5, 0x65, 0x45, 0x2d,
+ ],
+ [
+ 0x65, 0x62, 0x8e, 0x28, 0x24, 0x40, 0xbe, 0x6c, 0xa7, 0x24, 0x6c, 0xf2, 0x87,
+ 0x2b, 0xeb, 0x35, 0x60, 0xc3, 0x7b, 0x68, 0x43, 0x19, 0x47, 0xdf, 0xe5, 0xb4,
+ 0x15, 0xa6, 0x07, 0xd0, 0xd6, 0x65,
+ ],
+ [
+ 0x73, 0x19, 0xc6, 0x1a, 0x87, 0xf9, 0x65, 0xb6, 0x43, 0xcc, 0x42, 0x61, 0xf8,
+ 0x8c, 0x65, 0x40, 0x9f, 0xb5, 0xa7, 0x09, 0xd6, 0x74, 0xaa, 0x74, 0x91, 0x28,
+ 0x6b, 0xbf, 0xbb, 0x3a, 0x7e, 0x8e, 0xef, 0x84, 0x45, 0xb7, 0x36, 0x59, 0xd8,
+ 0x45, 0xc5, 0x60, 0x3e, 0x11, 0x30, 0xbb, 0x29, 0x74,
+ ],
+ [
+ 0x21, 0xfa, 0x4c, 0xfb, 0xf9, 0xc9, 0xf5, 0x63, 0xbe, 0x66, 0x2b, 0xf9, 0x70,
+ 0x13, 0x2e, 0x31, 0x2f, 0x9c, 0x20, 0x38, 0xd7, 0x82, 0xb7, 0xc0, 0xb0, 0x98,
+ 0xd3, 0xf2, 0x45, 0x7f, 0x35, 0x7e, 0xaf, 0x40, 0x7b, 0x40, 0x38, 0xb3, 0xda,
+ 0x8e, 0x94, 0x70, 0xa0, 0xf0, 0x4e, 0x69, 0x15, 0x04, 0x9a, 0x15, 0x31, 0x00,
+ 0x09, 0x83, 0x35, 0x48, 0x68, 0x58, 0xdd, 0xb8, 0x49, 0x90, 0x60, 0xa9,
+ ]
+ ),
+ test_case!(
+ [
+ 0x9e, 0xec, 0x21, 0x11, 0x1f, 0x1c, 0xff, 0xee, 0xfd, 0x85, 0xcb, 0x87, 0x20,
+ 0x33, 0x54, 0xdb, 0x64, 0xa7, 0x50, 0xbe, 0xb4, 0xad, 0x25, 0x46, 0x5f, 0x75,
+ 0x2e, 0x3e, 0x52, 0xac, 0xc4, 0x48, 0xaa, 0x71, 0x99, 0x75, 0x6c, 0xa1,
+ ],
+ [
+ 0x9c, 0x45, 0x5c, 0x9f, 0x54, 0xd2, 0xad, 0x2e, 0x79, 0x8a, 0x5a, 0x6c, 0x89,
+ 0xe9, 0x24, 0x34, 0x20, 0x35, 0xb3, 0x18,
+ ],
+ [
+ 0x95, 0x3a, 0x67, 0x6a, 0x83, 0xf6, 0x02, 0x98, 0xea, 0x33, 0xae, 0x32, 0xd1,
+ 0xdb, 0x5d, 0x28, 0x83, 0xb1, 0x68, 0x7e, 0xbe, 0xd2, 0xc0, 0xe3, 0x0e, 0xd1,
+ 0xe0, 0x6e, 0x2e, 0xb3, 0xfa, 0xe3,
+ ],
+ [
+ 0x65, 0x12, 0x95, 0x58, 0xfa, 0xd4, 0x43, 0x56, 0x05, 0xd6, 0x92, 0xe2, 0xdc,
+ 0xe3, 0x40, 0x05, 0x85, 0xdc, 0x46, 0xd4, 0xef, 0xca, 0x46, 0x8e, 0x24, 0x7e,
+ 0x7b, 0xd8, 0xb2, 0x11, 0xe5, 0xef, 0x68, 0xf9, 0xd1, 0xec, 0x10, 0xb7, 0x06,
+ 0x04, 0x9c, 0xeb, 0x04, 0x5b, 0xf1, 0x26, 0x1a, 0x3d,
+ ],
+ [
+ 0x98, 0xb8, 0x27, 0x6c, 0xd0, 0x18, 0x6b, 0xa2, 0x4c, 0xa1, 0x86, 0x68, 0x76,
+ 0x8e, 0x12, 0xdc, 0xa8, 0xc0, 0xbe, 0x7f, 0xd1, 0xcf, 0xb1, 0x73, 0xb3, 0x55,
+ 0xa9, 0x4b, 0xff, 0x16, 0x32, 0x83, 0x7e, 0x29, 0xc7, 0x01, 0xe2, 0x6f, 0x64,
+ 0x1b, 0x53, 0x85, 0x8d, 0x45, 0x95, 0x1b, 0x05, 0xb9, 0xed, 0xf7, 0xc3, 0x65,
+ 0xa5, 0xb2, 0xbb, 0x39, 0xcc, 0xdc, 0x45, 0xed, 0x62, 0x83, 0x45, 0xbf,
+ ]
+ ),
+ test_case!(
+ [
+ 0xe4, 0xa1, 0xf7, 0xe6, 0xe1, 0xcf, 0xda, 0xdb, 0x42, 0xad, 0xfc, 0x75, 0x8f,
+ 0x4b, 0x6e, 0x37, 0x56, 0xa6, 0x13, 0xba, 0xc1, 0xcd, 0x0a, 0xd4, 0x67, 0xa3,
+ 0xde, 0xdd, 0xab, 0x94, 0x73, 0x08, 0xb0, 0xcb, 0xf4, 0xc7, 0x3d, 0x4c, 0x71,
+ ],
+ [
+ 0x86, 0x00, 0x23, 0xf1, 0x78, 0x8c, 0x19, 0x44, 0xe3, 0x72, 0x8a, 0x25, 0xb8,
+ 0x74, 0x09, 0x2b, 0x5f, 0x83, 0x31, 0x69,
+ ],
+ [
+ 0xd8, 0x29, 0x11, 0xa6, 0x09, 0x06, 0xf5, 0x86, 0xa9, 0xed, 0x82, 0x18, 0xbe,
+ 0xe2, 0xdb, 0x59, 0x3b, 0x77, 0x33, 0xcf, 0x47, 0x77, 0x3b, 0x96, 0x83, 0xdb,
+ 0xb2, 0x74, 0x68, 0xed, 0x1e, 0x4f,
+ ],
+ [
+ 0xa4, 0x7e, 0x3b, 0xb5, 0x55, 0xff, 0xb7, 0x1a, 0xaa, 0xf1, 0xa7, 0x7b, 0x82,
+ 0xa8, 0x09, 0x19, 0xd7, 0xb8, 0xa6, 0x7e, 0x64, 0x37, 0x72, 0x87, 0x52, 0x61,
+ 0x0c, 0x5c, 0xd2, 0x35, 0x05, 0x69, 0x04, 0xd8, 0x7f, 0x92, 0x4a, 0x59, 0x1d,
+ 0x92, 0x15, 0x39, 0xee, 0x4a, 0x82, 0x25, 0x4f, 0x97,
+ ],
+ [
+ 0x67, 0x44, 0x63, 0xe9, 0x9d, 0xd6, 0x79, 0x3d, 0xa5, 0x4a, 0xf4, 0xfb, 0xd8,
+ 0x53, 0x80, 0xec, 0x16, 0x0e, 0x6a, 0x9c, 0x6b, 0x20, 0x96, 0x6e, 0x15, 0xca,
+ 0x21, 0xd3, 0x0b, 0x60, 0x37, 0x7b, 0x7e, 0xc5, 0xf3, 0x8a, 0xba, 0xfa, 0x4e,
+ 0x7f, 0x89, 0x69, 0xcc, 0x37, 0x03, 0xf3, 0xe9, 0x78, 0x76, 0x78, 0xb1, 0xd7,
+ 0xe5, 0x2c, 0xd6, 0x60, 0x33, 0xf2, 0x99, 0xa8, 0x3a, 0xf4, 0xc7, 0x65,
+ ]
+ ),
+ test_case!(
+ [
+ 0x7e, 0xf0, 0xfb, 0x04, 0x57, 0x1d, 0x94, 0x0e, 0x5f, 0xea, 0x9b, 0x25, 0x0c,
+ 0x27, 0x5d, 0xcd, 0x9f, 0x7a, 0x27, 0x89, 0x6d, 0x9b, 0xb9, 0x7e, 0xb4, 0x88,
+ 0x04, 0x85, 0x73, 0xbb, 0x94, 0xea, 0x5f, 0x3a, 0xeb, 0x3b, 0x52, 0xa4, 0x6f,
+ 0x91,
+ ],
+ [
+ 0x3a, 0x86, 0xca, 0x97, 0x7e, 0x3e, 0x9f, 0x67, 0x31, 0xa1, 0x1b, 0x74, 0x39,
+ 0x2c, 0x4e, 0x25, 0xce, 0x74, 0x1a, 0xd5,
+ ],
+ [
+ 0x89, 0x19, 0xc3, 0x23, 0xa5, 0x16, 0xa0, 0x6d, 0xf3, 0xc7, 0x7d, 0x5f, 0xdc,
+ 0x13, 0xfc, 0x9c, 0xdc, 0xc8, 0x69, 0x47, 0x34, 0xf7, 0x9f, 0x5e, 0x4b, 0x19,
+ 0xcb, 0xd7, 0xa5, 0x2f, 0x71, 0xc4,
+ ],
+ [
+ 0x40, 0x2f, 0xb5, 0x28, 0x03, 0xd5, 0x57, 0xba, 0xa3, 0x4b, 0x13, 0x5f, 0x1e,
+ 0x9e, 0xa7, 0x06, 0x2d, 0x42, 0x6f, 0x54, 0x2b, 0x84, 0x4d, 0xfd, 0x6e, 0xdd,
+ 0x4b, 0xc5, 0x8d, 0xde, 0x8a, 0x47, 0x82, 0x73, 0x01, 0x74, 0x9c, 0x2d, 0xf1,
+ 0x4f, 0x20, 0xc7, 0xe7, 0x23, 0xd1, 0xc7, 0x86, 0x37,
+ ],
+ [
+ 0x76, 0xe2, 0x3a, 0x8c, 0x23, 0x57, 0x6a, 0x6d, 0x77, 0xc1, 0xef, 0x5c, 0x29,
+ 0xa5, 0xe3, 0xeb, 0x55, 0x60, 0xf8, 0x19, 0x60, 0x86, 0x9d, 0xa0, 0xdb, 0x03,
+ 0x55, 0xf8, 0x78, 0x9f, 0x93, 0x9a, 0x1a, 0x1f, 0xcb, 0xde, 0x8a, 0xee, 0x3d,
+ 0x79, 0x60, 0x0f, 0x16, 0xba, 0xdb, 0xd0, 0x5e, 0x01, 0xcd, 0x49, 0xe0, 0x46,
+ 0x7c, 0x72, 0x75, 0xb2, 0x11, 0x1c, 0x73, 0x24, 0xe3, 0x72, 0x89, 0x64,
+ ]
+ ),
+ test_case!(
+ [
+ 0xda, 0x47, 0x7c, 0x20, 0x0c, 0x53, 0x39, 0x7a, 0x41, 0xe9, 0x04, 0xd6, 0xe2,
+ 0x37, 0x49, 0x47, 0xec, 0x22, 0x1a, 0x11, 0x4c, 0x5b, 0x42, 0x6f, 0xa4, 0x05,
+ 0x65, 0xfe, 0xb6, 0x91, 0x57, 0xc2, 0x9b, 0x74, 0x32, 0xb3, 0x8e, 0x97, 0x27,
+ 0xb5, 0x24,
+ ],
+ [
+ 0x0a, 0x5c, 0x93, 0xef, 0x9c, 0x3e, 0xe6, 0xf3, 0xa2, 0xbf, 0xf9, 0x2c, 0x20,
+ 0x86, 0x79, 0xbe, 0x72, 0xe3, 0x09, 0x55,
+ ],
+ [
+ 0xd6, 0xf2, 0x02, 0x92, 0xf9, 0x7c, 0x69, 0x4b, 0xd3, 0x40, 0xc5, 0xba, 0x7a,
+ 0xe5, 0x14, 0x07, 0xae, 0xcc, 0xc6, 0x4f, 0xbe, 0x46, 0x0a, 0x40, 0x54, 0x2b,
+ 0x8d, 0x35, 0x8e, 0xf9, 0x29, 0x32,
+ ],
+ [
+ 0x49, 0x2e, 0x95, 0x4a, 0xa9, 0x0c, 0x08, 0x94, 0x0e, 0x1e, 0xeb, 0xa4, 0x66,
+ 0xc2, 0xed, 0xa5, 0x97, 0xc3, 0x51, 0xdb, 0xe6, 0xe4, 0xa5, 0xad, 0x7a, 0xfd,
+ 0x7d, 0x6f, 0x42, 0xc3, 0xb4, 0x88, 0x5b, 0xef, 0xdc, 0xf0, 0x33, 0x0b, 0x33,
+ 0x45, 0xe8, 0xfc, 0x40, 0x41, 0x9f, 0x74, 0x45, 0x42,
+ ],
+ [
+ 0x31, 0x0f, 0x89, 0xbf, 0xf5, 0x8a, 0x25, 0xfb, 0x64, 0xd2, 0x79, 0xba, 0x07,
+ 0xab, 0xd2, 0x58, 0x61, 0x8c, 0x02, 0x10, 0x74, 0xed, 0xdb, 0x6e, 0x7f, 0xbe,
+ 0x64, 0x95, 0xcd, 0x67, 0xdd, 0x10, 0x32, 0x9a, 0x97, 0x19, 0xa6, 0xb5, 0x53,
+ 0x6c, 0x07, 0xe5, 0xcd, 0x67, 0xfe, 0xbe, 0x68, 0x7c, 0xe8, 0xe3, 0x9d, 0x78,
+ 0x3e, 0x1b, 0x26, 0x5e, 0x64, 0xb2, 0x2c, 0x60, 0x5a, 0xe6, 0x13, 0xc6,
+ ]
+ ),
+ test_case!(
+ [
+ 0xc9, 0x10, 0x25, 0x7f, 0xd5, 0x52, 0x42, 0x78, 0x75, 0xae, 0x3a, 0xcb, 0xc4,
+ 0x51, 0xd1, 0x67, 0x8a, 0xba, 0x32, 0xc5, 0xab, 0x0c, 0xce, 0x7a, 0xef, 0x0b,
+ 0xfa, 0xb9, 0x39, 0xbe, 0x72, 0xb5, 0x5c, 0x05, 0x1a, 0xdd, 0xf1, 0x91, 0x96,
+ 0x7e, 0x40, 0xe8,
+ ],
+ [
+ 0x07, 0x78, 0x50, 0x5c, 0x66, 0xe0, 0x14, 0x8c, 0x43, 0xc0, 0x89, 0x30, 0xaf,
+ 0xff, 0x85, 0x63, 0x7c, 0x68, 0xcf, 0x4c,
+ ],
+ [
+ 0x5a, 0x68, 0xee, 0xb1, 0xd5, 0x4a, 0x7f, 0xca, 0x24, 0x0a, 0x0b, 0xc6, 0x98,
+ 0xe0, 0xce, 0x6b, 0xd9, 0x3d, 0xfc, 0x81, 0xe4, 0x41, 0xf8, 0xef, 0x31, 0x57,
+ 0x15, 0x06, 0x15, 0xb6, 0x05, 0x7f,
+ ],
+ [
+ 0x4a, 0xe7, 0x77, 0xbc, 0x8f, 0x64, 0xe7, 0x31, 0x86, 0xe2, 0x38, 0x39, 0xb8,
+ 0x97, 0x01, 0x9e, 0x2a, 0x4f, 0x2a, 0x05, 0x56, 0x97, 0x68, 0x14, 0x5c, 0x3b,
+ 0x91, 0xf5, 0x1d, 0xf3, 0x20, 0x3a, 0xb4, 0x83, 0x10, 0xf6, 0x0b, 0xc9, 0x7b,
+ 0xe8, 0x36, 0x36, 0x64, 0x3a, 0xc7, 0xa2, 0xe8, 0x37,
+ ],
+ [
+ 0x11, 0x77, 0xf8, 0xd5, 0x62, 0x70, 0x46, 0xee, 0xa6, 0x6a, 0xd8, 0xfe, 0xe1,
+ 0x4b, 0xf6, 0xac, 0xca, 0xf4, 0x9e, 0xfb, 0x70, 0xbd, 0x78, 0x33, 0x99, 0x56,
+ 0x6e, 0xcd, 0x7a, 0x23, 0x0f, 0x44, 0xea, 0x47, 0x8d, 0xbc, 0xcb, 0x53, 0x91,
+ 0xdf, 0x06, 0x18, 0x64, 0x3c, 0x1b, 0xf5, 0x94, 0xd3, 0xeb, 0xa8, 0xdf, 0xf7,
+ 0x4e, 0x70, 0x98, 0x52, 0x2b, 0xa0, 0xa7, 0x9f, 0x53, 0x1e, 0x3c, 0xd5,
+ ]
+ ),
+ test_case!(
+ [
+ 0x89, 0x6b, 0xb1, 0xe2, 0x58, 0x28, 0x8e, 0xa0, 0x54, 0x40, 0x7f, 0x11, 0x56,
+ 0x59, 0xce, 0x03, 0x0f, 0x62, 0xf5, 0x17, 0xe9, 0xce, 0x2b, 0xe1, 0x2f, 0xaa,
+ 0x89, 0x1f, 0xaf, 0x34, 0xda, 0x8a, 0xed, 0x73, 0x28, 0xf1, 0x25, 0x48, 0x34,
+ 0xac, 0xd0, 0xb3, 0x2a,
+ ],
+ [
+ 0x1a, 0x93, 0x96, 0xdf, 0xb9, 0x5d, 0x50, 0x20, 0x1a, 0x02, 0xfc, 0x45, 0xaf,
+ 0x2d, 0x23, 0xe4, 0xf3, 0x4b, 0xdc, 0xb3,
+ ],
+ [
+ 0x9d, 0x36, 0x9c, 0x71, 0xca, 0x90, 0xb5, 0x34, 0xbe, 0x9c, 0x93, 0x6b, 0x51,
+ 0xeb, 0x30, 0x80, 0xf4, 0xfd, 0x95, 0x8f, 0x8b, 0xdf, 0x8e, 0x46, 0x6a, 0xa4,
+ 0xec, 0xbe, 0x6b, 0x1d, 0x2c, 0xe2,
+ ],
+ [
+ 0x97, 0x04, 0x07, 0xec, 0x33, 0xbb, 0x69, 0x40, 0xd7, 0x55, 0xca, 0x73, 0x94,
+ 0x7e, 0x0a, 0x0f, 0x84, 0x17, 0x84, 0x22, 0x9b, 0x6a, 0xab, 0xa0, 0x8b, 0x81,
+ 0xb4, 0x08, 0x86, 0x5e, 0xb1, 0xc7, 0xea, 0x87, 0x87, 0x27, 0xd0, 0x90, 0x05,
+ 0xf1, 0xf4, 0x07, 0x06, 0xae, 0x32, 0xeb, 0x36, 0x9e,
+ ],
+ [
+ 0x41, 0x07, 0xf1, 0x39, 0x65, 0x07, 0xa1, 0x7b, 0x45, 0xe6, 0x41, 0x4f, 0x21,
+ 0xe1, 0x0f, 0x6f, 0xc3, 0x40, 0x6d, 0xc5, 0xaa, 0xca, 0xe6, 0xeb, 0x45, 0x15,
+ 0xf2, 0x91, 0xc6, 0x68, 0x76, 0x57, 0x73, 0x16, 0x8b, 0x1a, 0x9c, 0x4f, 0x7d,
+ 0xf5, 0x64, 0xab, 0x7a, 0x09, 0x46, 0x96, 0x75, 0x8c, 0xf7, 0x8a, 0x14, 0x35,
+ 0x42, 0x80, 0xc0, 0xf6, 0x78, 0xe0, 0xc3, 0xcc, 0xfa, 0xd9, 0x28, 0x8b,
+ ]
+ ),
+ test_case!(
+ [
+ 0x6c, 0x8d, 0xe8, 0x8f, 0x42, 0x6b, 0x1a, 0xf8, 0xde, 0x5f, 0xf2, 0x40, 0xdd,
+ 0x3b, 0x39, 0x85, 0x41, 0x9c, 0xf5, 0xa8, 0x91, 0x94, 0xde, 0x20, 0x62, 0x80,
+ 0xb9, 0x82, 0xbe, 0x02, 0x4f, 0xdf, 0x2a, 0x32, 0xca, 0x59, 0xbb, 0xf7, 0xbf,
+ 0x2f, 0xa1, 0x37, 0x2e, 0x18,
+ ],
+ [
+ 0x89, 0x59, 0x0b, 0x53, 0x02, 0x3e, 0x70, 0xe1, 0xff, 0x64, 0x57, 0x97, 0x2b,
+ 0x1e, 0xf4, 0xfb, 0x54, 0xac, 0x01, 0x66,
+ ],
+ [
+ 0xb7, 0x66, 0x23, 0xb4, 0xe4, 0x86, 0xf5, 0x19, 0x62, 0xae, 0xb2, 0x19, 0x9c,
+ 0xe3, 0x79, 0x79, 0x83, 0x86, 0x4e, 0xff, 0xd7, 0x0e, 0x6e, 0x2b, 0x5f, 0x6d,
+ 0xc6, 0x3c, 0xb5, 0xa8, 0x12, 0x95,
+ ],
+ [
+ 0x26, 0x96, 0xde, 0x5e, 0xc8, 0x77, 0x52, 0xb7, 0xb4, 0x9a, 0x6a, 0x16, 0x67,
+ 0xfe, 0x91, 0xd6, 0x4b, 0x55, 0xbf, 0xc4, 0x5c, 0x5f, 0xc2, 0x47, 0xac, 0xb1,
+ 0x4d, 0x17, 0xee, 0x32, 0xc1, 0x75, 0xa8, 0x9c, 0x79, 0x6e, 0x58, 0x66, 0xcb,
+ 0xe7, 0x6c, 0xdc, 0x1c, 0xc9, 0xc7, 0xd7, 0x42, 0xdd,
+ ],
+ [
+ 0x0b, 0x0f, 0x2d, 0x9d, 0x8c, 0x7f, 0x42, 0x2e, 0x24, 0x3b, 0xc6, 0x3a, 0x9a,
+ 0xf1, 0x56, 0x93, 0x62, 0x03, 0xe1, 0xe2, 0xf4, 0xc4, 0xed, 0xa9, 0x48, 0x79,
+ 0x5d, 0xd2, 0xa2, 0xe5, 0x6f, 0xe1, 0xa2, 0x68, 0xa3, 0xfa, 0x95, 0x52, 0x5b,
+ 0x0a, 0xbd, 0x6d, 0x30, 0xf9, 0x61, 0x72, 0x50, 0xf6, 0x73, 0xa8, 0xd1, 0x0a,
+ 0xd4, 0x41, 0xc9, 0x0d, 0x7e, 0xc1, 0x45, 0x9e, 0x50, 0x97, 0x20, 0x3d,
+ ]
+ ),
+ test_case!(
+ [
+ 0x11, 0x94, 0xd3, 0x97, 0x1c, 0x7d, 0x20, 0xe2, 0xcc, 0x2f, 0x29, 0xa7, 0x96,
+ 0x14, 0x0f, 0xd9, 0xd3, 0x3f, 0x1b, 0xf2, 0x43, 0x46, 0x51, 0xec, 0x65, 0x53,
+ 0xf5, 0xc7, 0xa3, 0xc9, 0x65, 0x2e, 0x44, 0x46, 0x2a, 0x54, 0xa2, 0xaa, 0x22,
+ 0x5d, 0xc4, 0xe2, 0x15, 0x03, 0xc9,
+ ],
+ [
+ 0xbf, 0x36, 0xd5, 0xd7, 0xbb, 0xfa, 0x57, 0x5e, 0x59, 0x92, 0x4a, 0x9e, 0xc3,
+ 0x66, 0xc2, 0xa1, 0xea, 0xb5, 0xdb, 0x9a,
+ ],
+ [
+ 0x3f, 0x54, 0x1f, 0xba, 0x9b, 0xbd, 0x60, 0xae, 0x9c, 0xe4, 0x60, 0x93, 0x4d,
+ 0xc6, 0x32, 0x71, 0x90, 0x9c, 0x03, 0x4e, 0x89, 0x29, 0x17, 0x5b, 0x07, 0xae,
+ 0x21, 0xda, 0xda, 0x59, 0x9f, 0x63,
+ ],
+ [
+ 0x73, 0x16, 0xda, 0xea, 0x04, 0x65, 0xdc, 0xc8, 0xc5, 0x19, 0x96, 0xa7, 0xb4,
+ 0xad, 0xb5, 0x31, 0x4f, 0xd3, 0x37, 0x23, 0xe8, 0x33, 0x19, 0x1e, 0x33, 0x3c,
+ 0xaf, 0xe7, 0x39, 0x4c, 0x7b, 0x4a, 0x0c, 0x4c, 0xc6, 0x91, 0x10, 0xc3, 0x2c,
+ 0xba, 0xbd, 0x1d, 0x83, 0x7f, 0x0b, 0xc8, 0x20, 0xd4,
+ ],
+ [
+ 0x9a, 0xd8, 0x8d, 0xfa, 0x8a, 0x56, 0x0e, 0x06, 0xa6, 0x8d, 0xa2, 0xb5, 0xb4,
+ 0x6a, 0xdd, 0x9b, 0xe8, 0x48, 0x61, 0x33, 0xfe, 0x99, 0x56, 0x8a, 0xd4, 0x5f,
+ 0x9c, 0xc1, 0xda, 0xd6, 0xdb, 0xab, 0xbb, 0x5b, 0x64, 0xba, 0x09, 0xdf, 0x9c,
+ 0x1e, 0xb6, 0x8c, 0xfd, 0x75, 0x6e, 0xc8, 0x5d, 0x44, 0xcd, 0xc7, 0x9d, 0x3f,
+ 0x28, 0xfe, 0x8b, 0x64, 0x6c, 0x32, 0xcd, 0x89, 0x0e, 0x2a, 0x4e, 0xd1,
+ ]
+ ),
+ test_case!(
+ [
+ 0x2c, 0xca, 0xd2, 0x8f, 0xf9, 0xc3, 0x0f, 0xbf, 0x06, 0x1b, 0xb0, 0x7a, 0x15,
+ 0x6e, 0x2b, 0x8e, 0x36, 0x86, 0xf5, 0x00, 0xc4, 0x5e, 0x49, 0x7f, 0x8b, 0xbb,
+ 0x92, 0xad, 0x0d, 0xce, 0x7f, 0x71, 0x0c, 0x4c, 0xdf, 0x4d, 0x72, 0x32, 0x57,
+ 0x22, 0xe2, 0x02, 0x05, 0x25, 0x01, 0x26,
+ ],
+ [
+ 0x2a, 0xf3, 0x37, 0xb6, 0xaf, 0x81, 0x5a, 0xd6, 0x4e, 0x95, 0xcb, 0x6f, 0xd7,
+ 0x57, 0x8a, 0x54, 0xdb, 0x2d, 0x84, 0xb5,
+ ],
+ [
+ 0xbf, 0x7e, 0x37, 0x30, 0x80, 0xf1, 0xe3, 0x57, 0x33, 0xa7, 0x1b, 0x55, 0x17,
+ 0x2b, 0xa4, 0x66, 0x4c, 0xa8, 0x14, 0x88, 0xc4, 0xdf, 0x10, 0x01, 0x32, 0x3b,
+ 0x65, 0xb6, 0xbc, 0x14, 0x94, 0x9d,
+ ],
+ [
+ 0x4b, 0xe9, 0x0b, 0x3e, 0xd8, 0x8f, 0x84, 0xb7, 0xeb, 0x31, 0x8e, 0x2c, 0x85,
+ 0x83, 0xab, 0x2a, 0x61, 0x0b, 0x00, 0x32, 0x53, 0x69, 0xf5, 0x0a, 0xad, 0x11,
+ 0x9f, 0x24, 0x14, 0x2f, 0x56, 0x45, 0x5d, 0x76, 0x95, 0xf5, 0x03, 0x49, 0xa6,
+ 0x42, 0x25, 0xae, 0x08, 0xa7, 0xf4, 0x7c, 0x0d, 0xc9,
+ ],
+ [
+ 0xbe, 0xbc, 0x4b, 0xb0, 0x44, 0x1a, 0x50, 0x64, 0xce, 0x36, 0x78, 0x25, 0xe1,
+ 0x90, 0x6f, 0xc1, 0xc8, 0xbf, 0xd9, 0xe2, 0x66, 0x69, 0x90, 0xd5, 0xd7, 0x0b,
+ 0x87, 0x10, 0xe5, 0xa7, 0x90, 0x93, 0xde, 0x67, 0xc5, 0x94, 0x80, 0x19, 0xd8,
+ 0xb7, 0xf9, 0x48, 0x9a, 0xeb, 0x58, 0xe5, 0x2e, 0xca, 0xe1, 0xe8, 0x1f, 0x11,
+ 0x1c, 0x14, 0xf5, 0xda, 0x3c, 0xc2, 0x32, 0x28, 0x7e, 0x87, 0x69, 0xca,
+ ]
+ ),
+ test_case!(
+ [
+ 0xfb, 0x71, 0x78, 0x65, 0x7e, 0x2a, 0x03, 0x55, 0x0d, 0x2d, 0x22, 0x18, 0x65,
+ 0xd2, 0x8e, 0xae, 0xa0, 0xb9, 0x05, 0x44, 0xc8, 0x68, 0x10, 0x6b, 0xaa, 0xa6,
+ 0x7e, 0x20, 0xb8, 0x3e, 0xff, 0x2d, 0x99, 0xf8, 0x4e, 0x9b, 0x8f, 0xdc, 0x75,
+ 0x27, 0xde, 0x44, 0xae, 0x36, 0x33, 0x3c, 0x13,
+ ],
+ [
+ 0x47, 0x2a, 0x47, 0xdc, 0xda, 0xa3, 0xda, 0xb9, 0x64, 0x88, 0xad, 0x1d, 0xca,
+ 0x6e, 0x3b, 0x52, 0x63, 0x32, 0x0d, 0x86,
+ ],
+ [
+ 0x0c, 0xcb, 0x96, 0x36, 0x0a, 0xbe, 0xcc, 0x07, 0xf4, 0x1c, 0xf9, 0x30, 0x05,
+ 0x07, 0x00, 0x0f, 0x6a, 0xb8, 0x94, 0xbd, 0xa9, 0x20, 0x85, 0x97, 0x55, 0x6b,
+ 0x26, 0x35, 0x19, 0x40, 0xe6, 0xdb,
+ ],
+ [
+ 0x5e, 0x0f, 0xcc, 0x43, 0x58, 0x47, 0x50, 0x4a, 0x2d, 0xc0, 0x68, 0x7b, 0x8b,
+ 0xf6, 0xd5, 0x0a, 0x87, 0x17, 0x19, 0x6b, 0x45, 0xa6, 0xe1, 0xb6, 0xe9, 0x6c,
+ 0x92, 0x91, 0xc3, 0x8e, 0xa6, 0xdd, 0x55, 0xd3, 0x77, 0x1b, 0x21, 0x1d, 0x93,
+ 0xb8, 0xe8, 0x5b, 0x94, 0x7c, 0x49, 0x81, 0x66, 0x9d,
+ ],
+ [
+ 0xea, 0x93, 0xf2, 0x02, 0xbc, 0xf3, 0x54, 0x76, 0xc1, 0xd9, 0xdb, 0x4d, 0x10,
+ 0x05, 0x72, 0x5f, 0xbf, 0x54, 0xe3, 0xce, 0x29, 0x10, 0x36, 0xa3, 0xd6, 0xfc,
+ 0x69, 0x56, 0xbe, 0xaa, 0x6e, 0x35, 0x85, 0x43, 0xc6, 0x30, 0x65, 0x2d, 0x59,
+ 0x63, 0x1f, 0x2a, 0xde, 0x0b, 0x5a, 0x56, 0x72, 0x1e, 0x8a, 0xe8, 0x3f, 0x1c,
+ 0xe9, 0xc3, 0x69, 0x14, 0x06, 0xed, 0xd8, 0x37, 0x7c, 0x8b, 0x38, 0x6c,
+ ]
+ ),
+ test_case!(
+ [
+ 0xc9, 0x83, 0xe9, 0xe5, 0x7b, 0x98, 0xd8, 0xe3, 0x1a, 0xc4, 0x54, 0x0b, 0x9c,
+ 0x7e, 0x1b, 0xd4, 0x0e, 0x30, 0x47, 0x68, 0x78, 0xd4, 0x11, 0x04, 0xca, 0x7a,
+ 0xa2, 0xf6, 0x02, 0x0c, 0x81, 0xa3, 0xdd, 0x66, 0x87, 0x59, 0x76, 0x3e, 0x7e,
+ 0x30, 0x9e, 0x25, 0xed, 0xe6, 0x73, 0xbc, 0x35, 0x3d,
+ ],
+ [
+ 0xdb, 0xa0, 0x1a, 0x5a, 0x66, 0x3c, 0xc0, 0x9d, 0xe1, 0xde, 0x7c, 0xb9, 0xea,
+ 0x61, 0x3f, 0x03, 0x34, 0x88, 0x0d, 0xeb,
+ ],
+ [
+ 0x33, 0xb7, 0xcb, 0x12, 0xcc, 0x63, 0x2d, 0x58, 0x46, 0xe1, 0xf0, 0xc2, 0x35,
+ 0xb1, 0x5b, 0x2e, 0x78, 0xba, 0xd3, 0xd4, 0xe2, 0x39, 0xc5, 0x6f, 0xb4, 0x22,
+ 0x29, 0x95, 0x9a, 0xc1, 0x9e, 0x61,
+ ],
+ [
+ 0x46, 0x90, 0x27, 0x01, 0x7c, 0x8d, 0xe0, 0xa9, 0x4d, 0x7a, 0xa3, 0x66, 0x7b,
+ 0xc3, 0xe3, 0x63, 0xb6, 0x45, 0x5d, 0xec, 0xc7, 0x2c, 0xf4, 0x5e, 0x9c, 0xeb,
+ 0x1b, 0x66, 0x96, 0xa1, 0xa0, 0x65, 0x0c, 0x08, 0xfc, 0x0a, 0xfb, 0x10, 0x54,
+ 0x05, 0xb6, 0x12, 0xf0, 0x82, 0x31, 0xeb, 0x5b, 0x6d,
+ ],
+ [
+ 0x1d, 0x20, 0xf0, 0x5a, 0x6e, 0x15, 0x80, 0xdc, 0xfc, 0x8c, 0xa8, 0x19, 0xac,
+ 0x6f, 0x24, 0xdc, 0xef, 0x4b, 0x7d, 0x63, 0xee, 0xb8, 0x2a, 0xa5, 0xde, 0xfe,
+ 0xd7, 0x71, 0x9a, 0xb5, 0xa1, 0x3c, 0x48, 0x0a, 0x0b, 0x52, 0xa8, 0x4b, 0x2d,
+ 0x58, 0x08, 0xd5, 0x8c, 0x40, 0x61, 0x52, 0xaa, 0x11, 0xa5, 0xed, 0x4b, 0xff,
+ 0xf0, 0x2d, 0x95, 0x5e, 0xb4, 0x7e, 0x01, 0xcf, 0xc3, 0xcb, 0x44, 0xf8,
+ ]
+ ),
+ test_case!(
+ [
+ 0x5e, 0xfd, 0x66, 0x15, 0xf2, 0x09, 0x8e, 0x56, 0xab, 0x7f, 0xeb, 0x2b, 0x59,
+ 0x9d, 0xf0, 0x51, 0x8b, 0xef, 0xc3, 0xc4, 0xa2, 0xe6, 0xbc, 0x20, 0x0f, 0x7c,
+ 0x04, 0x72, 0x17, 0x77, 0x01, 0x66, 0x2e, 0x6b, 0x8d, 0x1d, 0xb6, 0x5b, 0x71,
+ 0xbc, 0x1a, 0x54, 0xa2, 0xca, 0x54, 0x17, 0xd6, 0xb9, 0xec,
+ ],
+ [
+ 0xbb, 0xdd, 0x49, 0x95, 0xe9, 0x00, 0xa6, 0x4e, 0xd0, 0x3b, 0x8e, 0x73, 0x89,
+ 0xd4, 0x0d, 0x18, 0x71, 0xd4, 0x2c, 0x86,
+ ],
+ [
+ 0xee, 0x54, 0x73, 0xe6, 0x6e, 0x57, 0xce, 0x46, 0x19, 0x9e, 0x97, 0x21, 0xce,
+ 0x82, 0xe2, 0x81, 0x40, 0x41, 0x9f, 0x73, 0x33, 0xe0, 0xb8, 0x02, 0xa0, 0x51,
+ 0xee, 0xeb, 0x29, 0x9d, 0x3b, 0x4b,
+ ],
+ [
+ 0x39, 0x03, 0xbd, 0x3c, 0x08, 0x73, 0xb5, 0x5b, 0xa8, 0xb1, 0x54, 0x70, 0xac,
+ 0x95, 0xaa, 0x8c, 0xfe, 0x95, 0x67, 0xbe, 0xce, 0x7b, 0x6b, 0x70, 0x52, 0xd5,
+ 0xb0, 0xb6, 0xd0, 0xc2, 0x40, 0x3c, 0x68, 0x18, 0xd4, 0x03, 0x1d, 0xe7, 0x59,
+ 0x1c, 0x43, 0x3f, 0xe0, 0x7c, 0x0a, 0x4f, 0x21, 0x8f,
+ ],
+ [
+ 0x29, 0x55, 0x1c, 0x3f, 0x00, 0xc2, 0x02, 0x60, 0x56, 0xac, 0xfd, 0x08, 0x02,
+ 0x3e, 0xc2, 0x59, 0x86, 0xe6, 0x7b, 0x45, 0xa9, 0xea, 0xff, 0x73, 0x56, 0xe6,
+ 0x27, 0xc6, 0x46, 0xb9, 0x38, 0x6d, 0xb4, 0x18, 0x58, 0x99, 0x14, 0x54, 0xcc,
+ 0x1d, 0x69, 0x08, 0xff, 0xa7, 0x1a, 0x0e, 0xe8, 0x2c, 0x9e, 0x8d, 0xec, 0xd8,
+ 0xee, 0x77, 0x78, 0x2e, 0xb2, 0x8c, 0xf1, 0x24, 0x1b, 0x39, 0x30, 0x23,
+ ]
+ ),
+ test_case!(
+ [
+ 0xf7, 0x40, 0x5a, 0xa3, 0x7f, 0xd3, 0xd2, 0x01, 0xbe, 0xd3, 0x10, 0xdc, 0xe2,
+ 0x3d, 0x9c, 0xa7, 0x8c, 0x2b, 0x84, 0x67, 0xdc, 0x81, 0x08, 0x95, 0x82, 0x3b,
+ 0xdf, 0xe7, 0xbc, 0x22, 0x46, 0x83, 0x55, 0x77, 0xe4, 0xd9, 0xad, 0xed, 0x7c,
+ 0x79, 0x10, 0x44, 0x0a, 0x70, 0x06, 0xcc, 0x49, 0x82, 0xf6, 0x05,
+ ],
+ [
+ 0x53, 0x7b, 0x67, 0xf4, 0x7f, 0x1b, 0x6b, 0x01, 0x17, 0xfc, 0x38, 0x6a, 0x5b,
+ 0xcd, 0xd9, 0xe6, 0xac, 0xd1, 0xe5, 0x87,
+ ],
+ [
+ 0x5e, 0xe3, 0xd0, 0xaa, 0x3d, 0xec, 0xe1, 0xad, 0x94, 0xe9, 0xd1, 0xe7, 0xbd,
+ 0x5d, 0xb0, 0x1d, 0xd7, 0x17, 0xdd, 0x41, 0xa9, 0xf3, 0x89, 0x83, 0xf7, 0xf9,
+ 0x19, 0x9f, 0x46, 0xd6, 0xe3, 0xb6,
+ ],
+ [
+ 0x6c, 0x69, 0x96, 0x9d, 0x44, 0xb2, 0x1f, 0xbc, 0xc0, 0x75, 0x01, 0x65, 0xbe,
+ 0xbe, 0x31, 0xc8, 0xe3, 0x9d, 0x55, 0x2f, 0xaf, 0x9b, 0x13, 0xda, 0x8d, 0xa9,
+ 0xec, 0x7e, 0x3d, 0xa0, 0xc7, 0xcf, 0x0d, 0x76, 0x6b, 0x12, 0xed, 0x34, 0x2e,
+ 0x83, 0x99, 0x46, 0x69, 0xd8, 0x2b, 0x3c, 0x66, 0x11,
+ ],
+ [
+ 0x99, 0x03, 0xdf, 0x7e, 0x06, 0x6c, 0x07, 0x1e, 0x4d, 0xd6, 0x92, 0xeb, 0xf2,
+ 0x48, 0x72, 0xe9, 0xd3, 0x23, 0x58, 0x63, 0x77, 0x19, 0x85, 0x83, 0xe3, 0x7f,
+ 0xc8, 0x07, 0xc4, 0xb1, 0xa1, 0xf7, 0x65, 0x5f, 0xdc, 0x6e, 0x8a, 0xc7, 0x98,
+ 0xb7, 0x09, 0xac, 0x04, 0xa0, 0xc5, 0x24, 0x03, 0xd3, 0x45, 0x22, 0x69, 0x0f,
+ 0xf4, 0xba, 0x63, 0x67, 0x3f, 0x20, 0x18, 0x23, 0xa5, 0x9e, 0x35, 0x68,
+ ]
+ ),
+ test_case!(
+ [
+ 0x2a, 0xdc, 0x00, 0x96, 0x8f, 0x27, 0x34, 0xb8, 0xd7, 0xe8, 0x6e, 0x42, 0xc1,
+ 0x25, 0xe7, 0xcf, 0xe1, 0x00, 0x13, 0x9c, 0x4b, 0xe3, 0x75, 0x83, 0x1a, 0x09,
+ 0x09, 0xe5, 0xa0, 0x93, 0x91, 0x7a, 0x8c, 0xe2, 0x13, 0xa9, 0x71, 0x48, 0x34,
+ 0x46, 0x67, 0x8b, 0xd9, 0x7f, 0xeb, 0xaf, 0x62, 0xc9, 0x92, 0x7d, 0x8e,
+ ],
+ [
+ 0xbc, 0xad, 0x81, 0xcc, 0x0c, 0x29, 0x8f, 0xe1, 0x5d, 0x0e, 0xc1, 0xe6, 0x65,
+ 0x08, 0x72, 0xfc, 0x78, 0x27, 0xc5, 0x3a,
+ ],
+ [
+ 0x2f, 0x2a, 0xc5, 0x04, 0x29, 0x6c, 0x27, 0xaa, 0xc7, 0x5f, 0x69, 0x79, 0xc4,
+ 0xe1, 0xae, 0x38, 0x61, 0xed, 0x25, 0xc6, 0xed, 0x41, 0x2f, 0x3b, 0xb8, 0xb9,
+ 0x41, 0x9b, 0xef, 0x4d, 0x15, 0x61,
+ ],
+ [
+ 0xea, 0xc1, 0x74, 0x8c, 0x9f, 0xf7, 0x13, 0x09, 0x18, 0x72, 0x41, 0xc9, 0x98,
+ 0x53, 0x02, 0x22, 0xb0, 0x93, 0x79, 0xa0, 0x8e, 0xea, 0x51, 0x22, 0xa3, 0x16,
+ 0x0b, 0xc8, 0xa6, 0xe9, 0xc3, 0x24, 0x9d, 0xbd, 0x5e, 0x68, 0x62, 0x0e, 0xb3,
+ 0x41, 0xea, 0x68, 0x5e, 0xc9, 0x0f, 0xd0, 0x5b, 0xe8,
+ ],
+ [
+ 0xf0, 0x50, 0x76, 0xed, 0x62, 0x4c, 0xf8, 0x35, 0xd8, 0xf3, 0x57, 0xc8, 0x98,
+ 0xbc, 0x5e, 0x07, 0x24, 0x3a, 0x01, 0x50, 0x9b, 0xe9, 0xef, 0x00, 0x0b, 0x97,
+ 0xec, 0x27, 0x96, 0x59, 0x36, 0xab, 0xd9, 0xc0, 0x1c, 0xd8, 0xc5, 0xf3, 0x7e,
+ 0xa9, 0xb6, 0x55, 0x05, 0x82, 0xc0, 0xe6, 0x27, 0xbb, 0xa4, 0x0f, 0xd5, 0x9f,
+ 0x06, 0xf0, 0x6a, 0x19, 0x94, 0x0e, 0x5a, 0xef, 0x6b, 0x1a, 0x0a, 0x3a,
+ ]
+ ),
+ test_case!(
+ [
+ 0x4e, 0x8c, 0xd7, 0x32, 0x43, 0x7e, 0xdd, 0x54, 0x1b, 0x03, 0x30, 0xac, 0xac,
+ 0xb7, 0x0a, 0xe0, 0x18, 0xa2, 0x32, 0x9f, 0x35, 0x8e, 0xb7, 0x34, 0x2c, 0xf3,
+ 0xf6, 0x35, 0x8f, 0x62, 0x26, 0x42, 0x2f, 0xd4, 0x59, 0x3c, 0xc8, 0xf8, 0x58,
+ 0xf3, 0x0f, 0x65, 0xd8, 0xe4, 0x8c, 0x88, 0x6a, 0x4c, 0xfb, 0x14, 0x56, 0xea,
+ ],
+ [
+ 0x3f, 0xb1, 0x23, 0x41, 0x2a, 0xd3, 0xdb, 0xcb, 0x43, 0x5c, 0x03, 0x1c, 0x62,
+ 0xd3, 0x7b, 0xf6, 0x19, 0x92, 0x9e, 0x72,
+ ],
+ [
+ 0xea, 0x7c, 0x5d, 0x3f, 0x37, 0x10, 0x32, 0x2e, 0x22, 0x00, 0x71, 0x4e, 0x5c,
+ 0xd7, 0xe3, 0x90, 0x73, 0x51, 0x0c, 0x11, 0xf0, 0xba, 0x0c, 0x70, 0xcf, 0x23,
+ 0x56, 0x6f, 0x1a, 0xfa, 0xe4, 0x86,
+ ],
+ [
+ 0x78, 0x33, 0xa4, 0xba, 0x03, 0xb1, 0x09, 0x54, 0xfe, 0x76, 0x12, 0xe5, 0xb0,
+ 0xbd, 0xf8, 0x1d, 0xe6, 0x6f, 0xfd, 0x63, 0xe8, 0x5c, 0x63, 0x40, 0x25, 0xde,
+ 0xb6, 0x3f, 0x02, 0xca, 0x55, 0xd5, 0x03, 0xcd, 0x9d, 0xd8, 0x8a, 0xf3, 0x34,
+ 0x28, 0xe7, 0x82, 0xdd, 0x46, 0xdc, 0x14, 0xb6, 0x17,
+ ],
+ [
+ 0x2d, 0xb5, 0xba, 0xf4, 0xd1, 0x1b, 0xc5, 0x70, 0x04, 0xc0, 0xf8, 0x99, 0x39,
+ 0xbd, 0x3f, 0x65, 0x16, 0xba, 0x26, 0xab, 0x5a, 0xcb, 0x5e, 0x13, 0x45, 0xde,
+ 0xa8, 0x4c, 0x13, 0x8f, 0x05, 0x98, 0x74, 0x47, 0x04, 0x11, 0x72, 0xa7, 0xe8,
+ 0x81, 0x45, 0x83, 0x32, 0x1e, 0x9e, 0xb5, 0x1b, 0x08, 0xa6, 0x7e, 0xe0, 0x75,
+ 0x05, 0x89, 0x5a, 0x69, 0x18, 0xa7, 0x0a, 0x00, 0x9e, 0x00, 0xa0, 0x07,
+ ]
+ ),
+ test_case!(
+ [
+ 0x7e, 0x5a, 0xc5, 0x2c, 0xec, 0x3a, 0xcc, 0xfd, 0x72, 0x35, 0x5f, 0x45, 0xf1,
+ 0xbb, 0x36, 0x53, 0xb7, 0x3c, 0xd8, 0x9d, 0xed, 0x39, 0x51, 0x9f, 0xb7, 0x98,
+ 0xcd, 0x88, 0x0f, 0x95, 0x63, 0xa8, 0x1f, 0x45, 0x9e, 0xbc, 0x9b, 0xfc, 0x2b,
+ 0x5a, 0x7d, 0x56, 0xd8, 0xfc, 0x8c, 0x09, 0xaa, 0x72, 0xdb, 0x2c, 0x7d, 0x9a,
+ 0x58,
+ ],
+ [
+ 0x2c, 0xb8, 0xb5, 0x49, 0xd8, 0x10, 0x80, 0x9d, 0xed, 0xb9, 0x3d, 0xcb, 0xfe,
+ 0xb9, 0x00, 0xd6, 0xae, 0x04, 0x77, 0xff,
+ ],
+ [
+ 0x22, 0x1f, 0x10, 0x7a, 0xdc, 0xc1, 0x84, 0xfa, 0x55, 0x89, 0xa2, 0x02, 0xad,
+ 0x1d, 0x5e, 0xe8, 0xce, 0xaf, 0x35, 0x0a, 0x1b, 0xc9, 0x23, 0x0a, 0x9a, 0x44,
+ 0x90, 0x72, 0xc6, 0x41, 0x4e, 0xb4,
+ ],
+ [
+ 0xa5, 0x9b, 0xf6, 0x79, 0xc0, 0x07, 0xb6, 0xcc, 0xbf, 0xcd, 0xfa, 0x56, 0x07,
+ 0x3a, 0xb8, 0x95, 0x59, 0x49, 0x27, 0x4e, 0x1e, 0xe8, 0x75, 0x9b, 0x04, 0x9d,
+ 0xa5, 0xc8, 0x0e, 0xcd, 0x8b, 0xa7, 0xc0, 0xc5, 0x8e, 0xb1, 0x4d, 0xa0, 0x25,
+ 0x08, 0xbe, 0x37, 0xc1, 0x6f, 0xd6, 0x59, 0x09, 0x61,
+ ],
+ [
+ 0xc0, 0xa3, 0x5e, 0x5b, 0x31, 0xd0, 0xc0, 0x3c, 0xd1, 0x37, 0xd3, 0x25, 0x22,
+ 0x50, 0xca, 0xbd, 0xa4, 0x85, 0x30, 0x64, 0xaf, 0x6f, 0xa1, 0xec, 0x0c, 0xc3,
+ 0x79, 0x08, 0xd2, 0x06, 0xaf, 0xd1, 0xd4, 0x43, 0xb9, 0xe0, 0xf6, 0x14, 0x3b,
+ 0x7c, 0xf2, 0xf8, 0x00, 0x47, 0x15, 0x85, 0xfd, 0xca, 0x5a, 0x65, 0xc7, 0x80,
+ 0xe1, 0xd0, 0x57, 0x79, 0x84, 0x0f, 0xd0, 0xe3, 0x12, 0x86, 0x99, 0x7e,
+ ]
+ ),
+ test_case!(
+ [
+ 0x4b, 0x3c, 0x61, 0xeb, 0x1a, 0x4f, 0x06, 0x8a, 0x24, 0xbc, 0xed, 0x90, 0xfd,
+ 0xd3, 0x00, 0xc8, 0xf2, 0xf7, 0xb4, 0x01, 0x57, 0x1c, 0x33, 0x94, 0x48, 0x7f,
+ 0x34, 0x5e, 0x89, 0xe4, 0x1c, 0xe4, 0xe0, 0x09, 0xe6, 0x12, 0xdf, 0x1b, 0x8e,
+ 0x14, 0x13, 0x62, 0x32, 0xc3, 0x30, 0x06, 0x87, 0xb2, 0x22, 0xaf, 0x5e, 0xb8,
+ 0x0b, 0xae,
+ ],
+ [
+ 0x3d, 0x11, 0x99, 0xb2, 0xd4, 0x58, 0x02, 0x6e, 0x1e, 0x24, 0xe6, 0x7d, 0x91,
+ 0x10, 0x7b, 0x3f, 0xd9, 0x58, 0xc2, 0xb7,
+ ],
+ [
+ 0x21, 0x4c, 0x6e, 0x88, 0x42, 0xb9, 0xc2, 0xe0, 0x33, 0x6d, 0xb4, 0x5f, 0x42,
+ 0x90, 0x16, 0xf1, 0x1d, 0x02, 0xf2, 0x1c, 0xba, 0xbc, 0xb9, 0xb5, 0x2d, 0x7a,
+ 0x16, 0xd0, 0x99, 0xc2, 0x93, 0x52,
+ ],
+ [
+ 0x33, 0x30, 0x2c, 0x21, 0xca, 0x13, 0x47, 0x9b, 0xd7, 0xb6, 0x2d, 0x43, 0x65,
+ 0x5f, 0xe2, 0xca, 0xbc, 0x5a, 0xdd, 0x3c, 0xd7, 0x68, 0xd9, 0xbe, 0x24, 0xae,
+ 0x77, 0xe1, 0x6a, 0xf7, 0x01, 0x9f, 0xcd, 0xf8, 0x2d, 0xc0, 0xeb, 0xa0, 0xc6,
+ 0x47, 0x73, 0xe3, 0x7c, 0x01, 0xf9, 0xf4, 0xbe, 0xd2,
+ ],
+ [
+ 0x99, 0x89, 0xea, 0x7f, 0xdb, 0x37, 0x99, 0xb2, 0xc7, 0x4e, 0xc5, 0x7e, 0x67,
+ 0x08, 0x6b, 0xc7, 0x74, 0x79, 0xde, 0xaa, 0x73, 0x6b, 0x48, 0x0e, 0x82, 0x56,
+ 0x7f, 0x82, 0x50, 0xf0, 0xda, 0x9b, 0x70, 0xf4, 0x76, 0x35, 0x58, 0x06, 0x3f,
+ 0x15, 0x78, 0xef, 0x3e, 0x0d, 0x28, 0x3d, 0x41, 0x34, 0x85, 0xe9, 0x43, 0xde,
+ 0xec, 0xd8, 0x38, 0x90, 0xb3, 0xf1, 0x58, 0x7d, 0x38, 0x24, 0xbc, 0x73,
+ ]
+ ),
+ test_case!(
+ [
+ 0x20, 0x12, 0xcd, 0x3f, 0x56, 0x5d, 0x24, 0x82, 0x80, 0x42, 0xfe, 0xa7, 0xba,
+ 0xca, 0xbd, 0x3a, 0x7b, 0x78, 0xda, 0x45, 0x39, 0x56, 0x34, 0x5d, 0x9b, 0x64,
+ 0x26, 0x58, 0x83, 0xb8, 0x00, 0x09, 0x17, 0x4c, 0xe4, 0x94, 0x5d, 0xff, 0x8e,
+ 0xb7, 0xf4, 0x8b, 0x58, 0xe9, 0x93, 0xd6, 0x60, 0x3c, 0xec, 0xc3, 0x26, 0xfa,
+ 0x7a, 0xf5, 0x9c,
+ ],
+ [
+ 0x02, 0x7e, 0x9c, 0x5b, 0x82, 0x8d, 0xf6, 0x5b, 0x8f, 0xad, 0xc2, 0x72, 0x92,
+ 0xdf, 0xb6, 0x7e, 0x3b, 0x83, 0xfc, 0x78,
+ ],
+ [
+ 0x69, 0x30, 0x2a, 0x89, 0xc1, 0x9e, 0x2b, 0xaf, 0x91, 0x15, 0x25, 0x51, 0x56,
+ 0xbf, 0xca, 0xe2, 0xc3, 0x09, 0x12, 0xe6, 0x68, 0xfe, 0x6b, 0x95, 0x33, 0x10,
+ 0xdf, 0xcc, 0x0e, 0x98, 0x77, 0x88,
+ ],
+ [
+ 0x16, 0x45, 0xa0, 0x94, 0xb3, 0x6f, 0x5f, 0xff, 0xb4, 0x1c, 0x38, 0xdb, 0x38,
+ 0xc5, 0xe1, 0xe0, 0xa5, 0x3f, 0xfd, 0x92, 0x68, 0x70, 0xf3, 0x17, 0xc8, 0x7f,
+ 0xbd, 0xb0, 0xc0, 0x18, 0xc3, 0x03, 0x7b, 0xc8, 0xe4, 0xc6, 0xd1, 0xf6, 0x4c,
+ 0x0d, 0x16, 0x9a, 0x68, 0xaf, 0x2d, 0xb3, 0x74, 0x86,
+ ],
+ [
+ 0x08, 0xba, 0x37, 0x6b, 0xc4, 0x2d, 0x03, 0xb0, 0x3a, 0x90, 0xad, 0x14, 0xc3,
+ 0xda, 0x8c, 0xff, 0x21, 0x8e, 0xf9, 0xf6, 0xae, 0x69, 0x0b, 0xd1, 0xe2, 0xb7,
+ 0x46, 0x0a, 0x8b, 0x46, 0xbb, 0xdf, 0x0b, 0x9a, 0xaf, 0x63, 0xc0, 0x73, 0xcc,
+ 0xe2, 0xf6, 0x3a, 0xe6, 0x7f, 0x68, 0xbc, 0x39, 0x38, 0x29, 0x79, 0x03, 0xb7,
+ 0x99, 0xf1, 0x62, 0x29, 0x7c, 0xb9, 0x3c, 0x8b, 0xbb, 0x48, 0x82, 0x21,
+ ]
+ ),
+ test_case!(
+ [
+ 0x83, 0x6a, 0xb3, 0xfd, 0x64, 0x00, 0x02, 0x41, 0x8e, 0x5b, 0xec, 0xc1, 0x21,
+ 0x2f, 0x1e, 0xaa, 0xe3, 0xf9, 0xd4, 0xe4, 0x21, 0xa6, 0x68, 0x15, 0xd6, 0x58,
+ 0x18, 0x72, 0x2f, 0x3b, 0x17, 0x9c, 0xfc, 0x71, 0x7d, 0x49, 0xa4, 0x92, 0x7b,
+ 0x93, 0x87, 0x52, 0xce, 0x71, 0x7f, 0xc6, 0x83, 0x83, 0xc5, 0x37, 0x53, 0xa0,
+ 0x3c, 0x8e, 0x21, 0x91,
+ ],
+ [
+ 0x1d, 0xd6, 0xc0, 0xad, 0x6c, 0x6e, 0xa5, 0x76, 0xbc, 0x67, 0x37, 0x05, 0x87,
+ 0x8b, 0x17, 0xc4, 0x80, 0x9f, 0xaf, 0x30,
+ ],
+ [
+ 0xfb, 0xbf, 0x79, 0x20, 0xaf, 0xcd, 0xb5, 0xaa, 0xf3, 0x4f, 0xca, 0xc9, 0x45,
+ 0xa7, 0x49, 0x1a, 0x85, 0x99, 0x37, 0xaf, 0xbd, 0x9c, 0x2c, 0x1c, 0xfe, 0xe8,
+ 0xe3, 0x20, 0x4d, 0x18, 0x66, 0x1e,
+ ],
+ [
+ 0xdf, 0x45, 0x40, 0xe9, 0x93, 0xb7, 0xee, 0x62, 0x41, 0xa1, 0x21, 0x0f, 0xd8,
+ 0x23, 0x9e, 0x6b, 0xa2, 0xc0, 0x9c, 0x4a, 0x0b, 0xff, 0xa9, 0x08, 0x7e, 0x35,
+ 0xda, 0x5b, 0x4b, 0x76, 0x7e, 0x37, 0x24, 0x14, 0x4f, 0x1c, 0xfa, 0xa6, 0x20,
+ 0xe7, 0xa2, 0xa7, 0x90, 0x98, 0x69, 0x15, 0x4b, 0x28,
+ ],
+ [
+ 0x03, 0xa4, 0x15, 0x16, 0x50, 0x00, 0x20, 0xb8, 0xf7, 0x6b, 0x94, 0xce, 0xa9,
+ 0x06, 0xf7, 0x1e, 0x88, 0x54, 0xe9, 0x15, 0xad, 0xe5, 0x0b, 0x4a, 0xa6, 0x5e,
+ 0x8b, 0x43, 0xf8, 0x9b, 0x5b, 0x0a, 0x49, 0x52, 0x49, 0x6c, 0x16, 0xec, 0x51,
+ 0xac, 0x2a, 0x0d, 0xb1, 0x89, 0x4b, 0x75, 0x97, 0x5c, 0xea, 0x4e, 0x52, 0xd2,
+ 0x06, 0x68, 0x8b, 0x13, 0xd8, 0x9b, 0x49, 0x82, 0xb9, 0x9b, 0x03, 0xc7,
+ ]
+ ),
+ test_case!(
+ [
+ 0x74, 0xda, 0xd3, 0x9e, 0xb7, 0x28, 0x06, 0x8e, 0x54, 0x04, 0x23, 0x02, 0x1a,
+ 0xf0, 0x40, 0xc8, 0xdf, 0xa1, 0xc9, 0x44, 0xca, 0x27, 0x2f, 0x5a, 0xe6, 0x10,
+ 0x6d, 0x57, 0x42, 0x39, 0x4f, 0x8a, 0x11, 0x49, 0x23, 0x6d, 0xf2, 0x2a, 0x01,
+ 0x61, 0xb8, 0xd0, 0xfe, 0x7d, 0xb0, 0xd4, 0x6e, 0x2e, 0xf2, 0xfd, 0x4f, 0x5d,
+ 0x15, 0x71, 0x76, 0x4d, 0xbb,
+ ],
+ [
+ 0x9e, 0x91, 0x66, 0xa2, 0x2d, 0xfc, 0x7f, 0xf2, 0x55, 0xee, 0x53, 0x06, 0x81,
+ 0xf1, 0x08, 0x8e, 0xf8, 0xfe, 0x86, 0x35,
+ ],
+ [
+ 0xeb, 0xc3, 0xeb, 0x13, 0x8e, 0xa3, 0x15, 0x39, 0xd3, 0xcb, 0x64, 0xc4, 0xa8,
+ 0xf8, 0x39, 0xe3, 0x0c, 0x00, 0x9b, 0x57, 0x93, 0x8f, 0x71, 0x43, 0xed, 0xa2,
+ 0xe8, 0x9c, 0x22, 0x7b, 0xbd, 0xc1,
+ ],
+ [
+ 0xd8, 0x62, 0x44, 0xfd, 0xed, 0x54, 0xbd, 0xe2, 0xae, 0xa0, 0x11, 0xe9, 0x56,
+ 0x2d, 0x7f, 0x0c, 0x43, 0x54, 0xc5, 0x40, 0xe6, 0x01, 0x99, 0x34, 0xd1, 0xe2,
+ 0x4d, 0xa9, 0x5d, 0x7b, 0x08, 0xaf, 0x02, 0x7f, 0x7d, 0x14, 0x1f, 0x31, 0x14,
+ 0xa5, 0xdd, 0x7a, 0x80, 0x2c, 0x53, 0x78, 0x18, 0x5c,
+ ],
+ [
+ 0xe4, 0x0d, 0x4b, 0xae, 0x97, 0x00, 0x68, 0x9d, 0xd6, 0x03, 0x7c, 0x5a, 0xae,
+ 0x27, 0x28, 0x3b, 0x55, 0x81, 0x9c, 0xe7, 0xbe, 0x55, 0x80, 0xc5, 0x7c, 0xcd,
+ 0x3d, 0xae, 0x22, 0x6d, 0x5f, 0x38, 0xb2, 0x1a, 0xc0, 0x7f, 0xee, 0x43, 0x7d,
+ 0xa1, 0x28, 0x2f, 0x02, 0xb0, 0xa6, 0x46, 0xf2, 0x52, 0x62, 0x27, 0x35, 0xc4,
+ 0x1d, 0x1a, 0xad, 0xb7, 0x8d, 0x4e, 0x53, 0x91, 0x47, 0x6c, 0x87, 0xd7,
+ ]
+ ),
+ test_case!(
+ [
+ 0x3e, 0xc0, 0x06, 0xb3, 0x2f, 0x90, 0xfc, 0x0b, 0x3f, 0x56, 0x5b, 0x7c, 0x81,
+ 0x1b, 0xe2, 0xc8, 0x67, 0x07, 0xc1, 0x34, 0x16, 0x93, 0x23, 0x0d, 0xdc, 0x9b,
+ 0xc4, 0x3f, 0xf7, 0x7b, 0x44, 0x4b, 0x49, 0x8f, 0x21, 0x23, 0xd2, 0xa2, 0x7e,
+ 0x88, 0xa9, 0x51, 0xbc, 0x7e, 0x33, 0x7c, 0x10, 0xf1, 0x10, 0x38, 0x3b, 0x7d,
+ 0xed, 0x92, 0xb0, 0x8b, 0x56, 0x01,
+ ],
+ [
+ 0xa0, 0x7f, 0x80, 0xd6, 0xa8, 0x22, 0xd8, 0x66, 0xc7, 0xba, 0xed, 0x7d, 0x6f,
+ 0x10, 0xeb, 0x33, 0x9e, 0xd5, 0xcf, 0x79,
+ ],
+ [
+ 0xb0, 0xd1, 0xa5, 0xa7, 0xac, 0x4e, 0x49, 0xcc, 0xad, 0xe9, 0xca, 0x1e, 0x25,
+ 0x9f, 0x8f, 0x41, 0x95, 0x8e, 0x6b, 0x6a, 0x9d, 0x71, 0x0b, 0xb5, 0x18, 0x3d,
+ 0xf4, 0x3e, 0xd5, 0xf8, 0x46, 0xc0,
+ ],
+ [
+ 0x4c, 0x1b, 0x33, 0xe1, 0x5c, 0xfa, 0x2a, 0xd8, 0xc5, 0x93, 0x01, 0x25, 0x42,
+ 0x97, 0x94, 0x61, 0xb4, 0x42, 0x0a, 0x9d, 0xa8, 0x35, 0x6a, 0x37, 0xe2, 0xc3,
+ 0x3d, 0xd4, 0x02, 0x21, 0x62, 0x4c, 0xc5, 0x6a, 0x14, 0x25, 0x39, 0xc6, 0x4b,
+ 0x57, 0x8e, 0x43, 0xa0, 0x37, 0xaa, 0xf8, 0xf7, 0x34,
+ ],
+ [
+ 0xe3, 0x8f, 0xc5, 0x73, 0xbc, 0x6d, 0x2c, 0xcf, 0x71, 0x4e, 0x09, 0x0c, 0xfd,
+ 0x59, 0xae, 0xbb, 0xc6, 0xf6, 0xac, 0x1d, 0x10, 0xd4, 0x21, 0xf9, 0xeb, 0xc5,
+ 0x26, 0xba, 0xaa, 0x15, 0x62, 0x7d, 0x8f, 0x3b, 0xb1, 0x59, 0x42, 0x3b, 0x65,
+ 0x1b, 0x2f, 0x46, 0x88, 0xbb, 0x44, 0x5d, 0x9a, 0x0a, 0x34, 0xde, 0x6e, 0x8c,
+ 0x76, 0xfb, 0x97, 0xd7, 0x74, 0xc2, 0x80, 0x39, 0x52, 0xce, 0xdf, 0xe5,
+ ]
+ ),
+ test_case!(
+ [
+ 0xea, 0x08, 0xf5, 0xaf, 0xfc, 0x45, 0x8a, 0xec, 0xba, 0x30, 0x0e, 0x12, 0xc4,
+ 0x61, 0xa5, 0x07, 0x83, 0xe6, 0x7e, 0xc4, 0xfa, 0x97, 0x60, 0x9b, 0xa0, 0xa4,
+ 0x05, 0x43, 0xe8, 0x0a, 0x1a, 0xe4, 0x6a, 0x80, 0xf4, 0x90, 0x0a, 0xbd, 0xe7,
+ 0xa3, 0x49, 0x72, 0x2c, 0x25, 0x9b, 0x8d, 0x1a, 0x05, 0xd5, 0xa5, 0x97, 0xe9,
+ 0x50, 0x88, 0xea, 0xcb, 0x2a, 0x1b, 0xdb,
+ ],
+ [
+ 0x5b, 0x4d, 0xb6, 0x1a, 0xb2, 0xc8, 0x2a, 0xd6, 0xb3, 0xe6, 0xe1, 0x11, 0x21,
+ 0x96, 0x15, 0x92, 0x8b, 0xfe, 0x61, 0x67,
+ ],
+ [
+ 0x25, 0x7f, 0x71, 0xb1, 0xa7, 0xa3, 0xd2, 0x3d, 0xdd, 0x75, 0x3a, 0x18, 0x0d,
+ 0xa6, 0xd2, 0x4c, 0xc7, 0x90, 0x5d, 0x58, 0xeb, 0x98, 0x38, 0x6a, 0xca, 0x68,
+ 0x2d, 0x22, 0x35, 0x6d, 0xe7, 0xe9,
+ ],
+ [
+ 0xdd, 0x9d, 0x0c, 0x30, 0x11, 0x1b, 0xf7, 0x6a, 0x30, 0x65, 0xb4, 0xa3, 0x0b,
+ 0x4a, 0x32, 0xa5, 0xcb, 0x48, 0x8e, 0x5e, 0x97, 0x80, 0x42, 0x57, 0x55, 0x92,
+ 0xb9, 0x7f, 0x62, 0xb6, 0xeb, 0xfe, 0x35, 0x08, 0x45, 0x71, 0x55, 0x75, 0xc7,
+ 0x71, 0x07, 0x3d, 0x4f, 0xb5, 0x90, 0xd6, 0xec, 0xcb,
+ ],
+ [
+ 0xd4, 0xc8, 0x0b, 0x56, 0x4b, 0x9d, 0x1a, 0x66, 0x1a, 0x77, 0xb0, 0x3c, 0xb8,
+ 0x2e, 0xd6, 0xcf, 0xe0, 0x4b, 0xe7, 0xd0, 0x1a, 0xde, 0x00, 0xc3, 0xf3, 0xbc,
+ 0x73, 0x1d, 0xd2, 0x87, 0x19, 0xb9, 0xdd, 0x23, 0x05, 0x92, 0x62, 0x85, 0x0d,
+ 0x80, 0x53, 0xb4, 0x66, 0x51, 0x0e, 0x80, 0x41, 0x42, 0xaa, 0xcd, 0x38, 0xec,
+ 0x7b, 0x64, 0xe7, 0x78, 0xf9, 0x42, 0xe4, 0xd3, 0x85, 0x4b, 0x03, 0xf7,
+ ]
+ ),
+ test_case!(
+ [
+ 0x49, 0x3d, 0x3b, 0x5f, 0x12, 0x45, 0xeb, 0x38, 0x55, 0xc2, 0x4c, 0x4f, 0x48,
+ 0x3e, 0x58, 0xb1, 0x04, 0x70, 0xe1, 0xb7, 0x7f, 0xcc, 0x8b, 0x68, 0x27, 0xb0,
+ 0x1e, 0xab, 0xd8, 0x17, 0xa5, 0xbe, 0xd4, 0xbf, 0xf4, 0x43, 0x4a, 0x49, 0xd8,
+ 0xb7, 0x13, 0xe8, 0xa7, 0x4a, 0xae, 0x93, 0x3e, 0x97, 0xa0, 0xbf, 0x41, 0xa1,
+ 0x7e, 0x91, 0x0e, 0x75, 0x41, 0x5f, 0x66, 0x7d,
+ ],
+ [
+ 0x75, 0xe7, 0xa8, 0x12, 0x52, 0xda, 0xf3, 0xfe, 0x57, 0x92, 0xe3, 0x40, 0x3e,
+ 0x5e, 0x61, 0x11, 0xb0, 0x3a, 0x72, 0x09,
+ ],
+ [
+ 0x9e, 0x29, 0xa7, 0xfc, 0xef, 0x76, 0x4b, 0x1f, 0x69, 0x2a, 0x81, 0xda, 0xa2,
+ 0xd3, 0xa2, 0x11, 0x61, 0x15, 0xdf, 0xc4, 0x99, 0xde, 0xd3, 0x4c, 0xd9, 0x1e,
+ 0x6a, 0x73, 0xc8, 0xe9, 0xd2, 0x7e,
+ ],
+ [
+ 0x0c, 0xbb, 0x52, 0xe0, 0x3f, 0x97, 0x41, 0x60, 0xd5, 0x59, 0xbe, 0x36, 0xac,
+ 0xd9, 0xc6, 0x2e, 0xb6, 0x04, 0x0c, 0x0a, 0x37, 0x44, 0x3b, 0x60, 0x22, 0x96,
+ 0x23, 0xd8, 0x31, 0x56, 0x74, 0x6b, 0x99, 0xdb, 0xd5, 0xc6, 0x3d, 0x2b, 0x47,
+ 0xae, 0xa7, 0x2a, 0x7a, 0xc0, 0xee, 0xa5, 0x98, 0x62,
+ ],
+ [
+ 0x3c, 0xa7, 0xeb, 0xe2, 0x13, 0x88, 0x3d, 0x2a, 0xc9, 0x4f, 0x67, 0xf9, 0x43,
+ 0xea, 0x07, 0x75, 0xd9, 0x40, 0x28, 0x5a, 0x48, 0xdd, 0x0e, 0xc4, 0x63, 0xa9,
+ 0x9c, 0x77, 0x3d, 0xed, 0x07, 0x3b, 0x5c, 0xdf, 0x62, 0x04, 0xf4, 0x64, 0x85,
+ 0x35, 0x8e, 0x88, 0xe9, 0x4b, 0x86, 0x78, 0x5d, 0x71, 0x3d, 0x97, 0x27, 0x27,
+ 0x72, 0x56, 0xc7, 0xd3, 0x5d, 0xd5, 0x2e, 0x7c, 0xee, 0xdd, 0x74, 0x11,
+ ]
+ ),
+ test_case!(
+ [
+ 0xd7, 0x63, 0x65, 0xc1, 0x3f, 0x6d, 0x92, 0xfe, 0x90, 0xf0, 0x8f, 0x2c, 0xba,
+ 0x73, 0x2a, 0x2b, 0x88, 0x9e, 0x5d, 0xe0, 0x0c, 0x65, 0xea, 0xed, 0xf5, 0xaa,
+ 0x5c, 0x6c, 0x06, 0x94, 0x65, 0xde, 0x75, 0x9e, 0x14, 0x1e, 0x2b, 0x7f, 0x73,
+ 0xdb, 0xb7, 0x3b, 0xb7, 0x8e, 0x69, 0xc5, 0x0e, 0xf7, 0xaa, 0x77, 0x6c, 0x8b,
+ 0xbc, 0x1a, 0x30, 0x00, 0xd3, 0xa2, 0x77, 0x42, 0x7f,
+ ],
+ [
+ 0x0b, 0xa6, 0xb9, 0x91, 0x4b, 0x19, 0xe3, 0xea, 0x54, 0x9b, 0x82, 0x41, 0x09,
+ 0xd8, 0x1d, 0x99, 0x74, 0xa0, 0x95, 0x16,
+ ],
+ [
+ 0xd0, 0xf1, 0x55, 0x65, 0x17, 0xc2, 0x1e, 0x4f, 0x61, 0xc9, 0xcb, 0xcc, 0x83,
+ 0x27, 0x0d, 0x29, 0x04, 0x6f, 0x86, 0x91, 0x07, 0xd8, 0x0a, 0x76, 0x37, 0x0d,
+ 0x0c, 0x43, 0x75, 0xd8, 0xca, 0xce,
+ ],
+ [
+ 0x4f, 0x42, 0x31, 0xc0, 0xce, 0x03, 0xf7, 0x8c, 0x63, 0x29, 0xb1, 0x36, 0xde,
+ 0x8d, 0x82, 0xcb, 0x06, 0xbf, 0x55, 0x2d, 0x1f, 0x9a, 0xa3, 0x20, 0x63, 0x67,
+ 0xcb, 0xdc, 0x54, 0x9b, 0x92, 0xdd, 0xac, 0x30, 0x3b, 0x79, 0xcf, 0x7c, 0xe3,
+ 0x46, 0xac, 0x4a, 0xfe, 0xd7, 0x37, 0xbd, 0x79, 0x5e,
+ ],
+ [
+ 0x40, 0x36, 0xe6, 0xf5, 0xfa, 0xf5, 0x70, 0x3e, 0x41, 0xd2, 0x58, 0x81, 0x59,
+ 0x16, 0x23, 0xce, 0x22, 0x4a, 0x9b, 0xb0, 0x0c, 0xd0, 0xf9, 0x72, 0x78, 0x6a,
+ 0xa4, 0x43, 0x5b, 0x69, 0x96, 0xfc, 0xab, 0x45, 0x87, 0x81, 0xe9, 0xa4, 0x6c,
+ 0x3c, 0x2f, 0xc9, 0x57, 0x81, 0xec, 0xc7, 0x16, 0x53, 0x18, 0xf3, 0xfa, 0xd5,
+ 0xdf, 0x09, 0xe0, 0x08, 0xf2, 0xe7, 0x93, 0xc7, 0xcc, 0x7b, 0x43, 0xac,
+ ]
+ ),
+ test_case!(
+ [
+ 0x51, 0xda, 0x57, 0x9f, 0x2f, 0x75, 0x31, 0x51, 0x49, 0xd2, 0x83, 0xa4, 0x78,
+ 0xb2, 0xa8, 0x20, 0x43, 0x04, 0x09, 0xad, 0xfd, 0x17, 0x31, 0xbd, 0xea, 0xd2,
+ 0x84, 0x67, 0x53, 0x6f, 0x0b, 0x2f, 0xaa, 0x40, 0x23, 0xdc, 0x90, 0x34, 0x1a,
+ 0x27, 0x0e, 0x90, 0x34, 0x6f, 0x9c, 0xd1, 0x03, 0xa1, 0x16, 0x64, 0x1e, 0x6c,
+ 0x59, 0xa4, 0xc9, 0x4e, 0xb6, 0xc8, 0x28, 0xfb, 0x3d, 0x49,
+ ],
+ [
+ 0xfa, 0x72, 0xd9, 0x0c, 0x96, 0x70, 0xd0, 0xf5, 0xec, 0x5d, 0xda, 0x8d, 0xde,
+ 0x87, 0x2d, 0x90, 0xba, 0x08, 0x82, 0xd9,
+ ],
+ [
+ 0x98, 0xe0, 0xd1, 0x68, 0xf6, 0xd1, 0xd4, 0xa5, 0xf1, 0xad, 0x1c, 0x86, 0x22,
+ 0x63, 0x1b, 0x40, 0x88, 0x6f, 0xde, 0x1c, 0x17, 0xb2, 0x7a, 0xa5, 0x10, 0x01,
+ 0x59, 0xc6, 0x1f, 0xf8, 0xe2, 0xac,
+ ],
+ [
+ 0x8f, 0xab, 0xf0, 0x54, 0x18, 0xfe, 0xdc, 0x5e, 0xd2, 0x21, 0x94, 0x7d, 0x1e,
+ 0x0f, 0xc6, 0x8d, 0xaa, 0xc7, 0xf7, 0xcb, 0x9b, 0xf6, 0x74, 0x22, 0xb2, 0xdd,
+ 0xd2, 0x5c, 0x69, 0x32, 0xc8, 0x25, 0x93, 0x3f, 0x88, 0xf3, 0x53, 0xfb, 0x8d,
+ 0x6e, 0x79, 0xeb, 0x3a, 0x9f, 0x92, 0xd5, 0x6d, 0x01,
+ ],
+ [
+ 0xdd, 0x7d, 0x95, 0xa2, 0xc0, 0x34, 0xa0, 0xf0, 0xd6, 0xb7, 0x06, 0xd6, 0x03,
+ 0x98, 0xc2, 0x12, 0x76, 0x24, 0x5e, 0xe6, 0x55, 0x95, 0xdb, 0x51, 0xb3, 0x7b,
+ 0x16, 0x40, 0x3a, 0xf5, 0xd7, 0x2b, 0x88, 0x72, 0xfc, 0x1b, 0x29, 0x37, 0xe7,
+ 0x2c, 0x55, 0xd0, 0xbd, 0x50, 0xc6, 0xa7, 0x86, 0xb9, 0xf7, 0xba, 0xcb, 0xad,
+ 0x06, 0x38, 0x86, 0x38, 0x75, 0x3f, 0xd0, 0xb0, 0x3f, 0x19, 0xc0, 0x7c,
+ ]
+ ),
+ test_case!(
+ [
+ 0x9f, 0x4f, 0x0c, 0x66, 0x5b, 0xe4, 0x16, 0x82, 0x77, 0xb5, 0x9b, 0xea, 0x83,
+ 0xe2, 0x74, 0x44, 0x9f, 0x90, 0x8d, 0x82, 0x34, 0xae, 0xf4, 0xdb, 0x10, 0x04,
+ 0x26, 0x57, 0x36, 0x4e, 0x97, 0x85, 0xa3, 0x01, 0xa0, 0x04, 0xe6, 0x32, 0x1b,
+ 0xfb, 0x5a, 0x41, 0x10, 0xcf, 0x56, 0xa4, 0x74, 0xb2, 0xfe, 0x5c, 0xbb, 0xc7,
+ 0x59, 0x15, 0xca, 0xd8, 0x73, 0x3e, 0x9f, 0x03, 0xb3, 0x04, 0xa1,
+ ],
+ [
+ 0x31, 0x63, 0xe9, 0x1a, 0x83, 0x3d, 0xf0, 0x94, 0xbd, 0x55, 0xcc, 0x8e, 0x3b,
+ 0x84, 0xa3, 0x2f, 0xb7, 0x1e, 0xca, 0x98,
+ ],
+ [
+ 0xe6, 0xbb, 0xa4, 0x1e, 0xd4, 0x12, 0x08, 0xe6, 0xbc, 0xb5, 0xd6, 0x08, 0x95,
+ 0x8a, 0x21, 0x72, 0x14, 0xd3, 0x96, 0xd2, 0x96, 0x27, 0xf7, 0xf2, 0x7d, 0x91,
+ 0x4a, 0x6c, 0xb0, 0xeb, 0x90, 0xef,
+ ],
+ [
+ 0xe7, 0x9c, 0x3e, 0x7e, 0x14, 0xa9, 0xef, 0x71, 0x82, 0xb0, 0x13, 0xea, 0xdc,
+ 0xb4, 0x9f, 0x12, 0x32, 0x2c, 0xd8, 0xc3, 0x23, 0xfd, 0x22, 0x34, 0xf2, 0xec,
+ 0xd8, 0x0b, 0x8a, 0xa2, 0x87, 0x49, 0x56, 0x0d, 0xb8, 0x88, 0x03, 0xd5, 0xd1,
+ 0x3c, 0x6d, 0x0d, 0xf2, 0x01, 0x46, 0x05, 0x3e, 0x0c,
+ ],
+ [
+ 0x50, 0xf7, 0x59, 0x2c, 0x43, 0x52, 0x95, 0xd8, 0xac, 0xff, 0xc8, 0xf9, 0xad,
+ 0x7d, 0x53, 0x94, 0x8b, 0x26, 0xb5, 0xfa, 0xd6, 0xdd, 0x96, 0xfa, 0x2c, 0x56,
+ 0x9c, 0x19, 0xcb, 0xa0, 0x4c, 0xf4, 0xad, 0xea, 0xf3, 0xbd, 0xb2, 0x13, 0x01,
+ 0xf5, 0x54, 0x29, 0x00, 0xc8, 0xc4, 0x9f, 0xed, 0xf5, 0x71, 0x10, 0x82, 0xa1,
+ 0x41, 0x47, 0x51, 0x86, 0x90, 0xe4, 0xf3, 0xcf, 0xc4, 0xa0, 0x9b, 0xd8,
+ ]
+ ),
+ test_case!(
+ [
+ 0xb8, 0xe3, 0x7b, 0x37, 0xed, 0x17, 0xcd, 0x85, 0xfe, 0x05, 0x07, 0x74, 0x51,
+ 0xff, 0xcd, 0x0b, 0x0a, 0xc4, 0xfc, 0xf0, 0xa5, 0xe0, 0x81, 0xd9, 0xdd, 0xc5,
+ 0xa6, 0x42, 0x76, 0x92, 0x6d, 0xaf, 0x89, 0x36, 0xed, 0x13, 0x51, 0xe0, 0x1e,
+ 0xe6, 0x73, 0x7a, 0xbc, 0x17, 0xb8, 0x3d, 0x34, 0x11, 0x32, 0x1a, 0xab, 0xaa,
+ 0x2c, 0xce, 0x4b, 0x70, 0x58, 0xe4, 0xfc, 0x80, 0x94, 0x17, 0xc9, 0x43,
+ ],
+ [
+ 0x26, 0xc1, 0xd3, 0x8f, 0x3e, 0x50, 0xe3, 0x8e, 0x1e, 0xea, 0x6f, 0x03, 0xbf,
+ 0xb5, 0x39, 0x30, 0x0f, 0xa8, 0xc5, 0x8a,
+ ],
+ [
+ 0xc1, 0xc3, 0x88, 0xbc, 0xfb, 0x88, 0x27, 0xac, 0xa2, 0x88, 0xa5, 0xeb, 0xc1,
+ 0xa9, 0xa8, 0xdb, 0xab, 0x3b, 0xf9, 0xa0, 0xa4, 0xc8, 0xee, 0x4a, 0x95, 0x00,
+ 0x26, 0x9e, 0xe0, 0x12, 0x04, 0x52,
+ ],
+ [
+ 0x9c, 0x18, 0x4d, 0x78, 0x78, 0x7d, 0x59, 0x46, 0x5e, 0xff, 0x7e, 0xaf, 0xeb,
+ 0x36, 0x66, 0xaa, 0x43, 0xf7, 0xe4, 0x74, 0x70, 0x45, 0x7e, 0x0a, 0x36, 0x45,
+ 0x2c, 0x91, 0xa2, 0xdd, 0x2a, 0xb0, 0xce, 0xb7, 0xe9, 0xb0, 0x90, 0x8d, 0xe2,
+ 0xa9, 0xf6, 0x3e, 0x2a, 0xce, 0x5f, 0xea, 0x9e, 0xc8,
+ ],
+ [
+ 0x9b, 0xd3, 0x64, 0x59, 0xcb, 0x9f, 0xc4, 0xa6, 0x84, 0x76, 0x24, 0xf4, 0x44,
+ 0x05, 0xcf, 0x87, 0x7c, 0x5d, 0x74, 0x56, 0x27, 0xa1, 0xae, 0x64, 0x3d, 0x46,
+ 0xbc, 0xff, 0x0c, 0x23, 0x4f, 0xea, 0x46, 0xf6, 0xd4, 0x5f, 0xae, 0xbe, 0x6d,
+ 0x93, 0x3a, 0xa8, 0xd2, 0x2e, 0x73, 0x89, 0xa1, 0x82, 0x24, 0x7f, 0x60, 0x0f,
+ 0x7d, 0x34, 0x3e, 0xa5, 0xdc, 0x73, 0xb7, 0xa9, 0x7b, 0xd6, 0xca, 0xeb,
+ ]
+ ),
+ test_case!(
+ [
+ 0xb8, 0x72, 0x0a, 0x4c, 0x3b, 0xaa, 0x7f, 0xc7, 0x5d, 0xc3, 0x2e, 0x7d, 0x11,
+ 0x76, 0x11, 0x92, 0x49, 0x08, 0xf1, 0x06, 0xeb, 0x9e, 0xf3, 0x0a, 0x0d, 0x5e,
+ 0x76, 0xbe, 0x97, 0x52, 0xf4, 0x8b, 0x95, 0x6a, 0x5c, 0xa1, 0x5b, 0x81, 0xe1,
+ 0x2b, 0xc7, 0x46, 0xa3, 0x17, 0x83, 0x0e, 0xa9, 0x67, 0x07, 0x56, 0xcc, 0x4f,
+ 0x35, 0xed, 0x8d, 0xcb, 0x0c, 0xb3, 0x07, 0xd1, 0x2f, 0x9e, 0x2c, 0x7f, 0x28,
+ ],
+ [
+ 0x66, 0x61, 0xa3, 0xb9, 0xbd, 0x4c, 0xf1, 0xec, 0xb9, 0x74, 0x6d, 0x55, 0x7e,
+ 0x22, 0xdf, 0x8a, 0x86, 0x17, 0x0d, 0x19,
+ ],
+ [
+ 0xec, 0x45, 0x1c, 0xdd, 0xbd, 0xc2, 0xe1, 0x27, 0x77, 0x7a, 0x42, 0x34, 0x72,
+ 0x2d, 0xed, 0xc4, 0xde, 0x93, 0x1d, 0x38, 0x45, 0x56, 0xf2, 0xc5, 0xc6, 0x07,
+ 0xb4, 0x01, 0xc7, 0x34, 0x73, 0xd3,
+ ],
+ [
+ 0x85, 0xd5, 0xbc, 0x24, 0xff, 0x30, 0x5d, 0xa0, 0x2f, 0x7b, 0x52, 0x8a, 0x51,
+ 0xf5, 0x00, 0xe1, 0x92, 0xb7, 0xb7, 0xd3, 0x23, 0x2f, 0xb9, 0x8c, 0x16, 0x75,
+ 0xad, 0x1f, 0x90, 0xf9, 0x85, 0xbe, 0x3a, 0xad, 0x43, 0x28, 0xe9, 0x03, 0x7c,
+ 0x39, 0xed, 0x57, 0x6c, 0xb0, 0x1b, 0x97, 0xf5, 0x09,
+ ],
+ [
+ 0x53, 0x6d, 0x5c, 0xd4, 0x19, 0x49, 0xa7, 0x26, 0x54, 0x05, 0xdd, 0x6d, 0x7e,
+ 0x7c, 0x35, 0xeb, 0x0c, 0xdd, 0xfd, 0xdc, 0x8c, 0xc1, 0x90, 0xdf, 0xf0, 0xb1,
+ 0xe5, 0x57, 0x59, 0xfb, 0x8f, 0x88, 0x4f, 0xb8, 0xe2, 0x4b, 0xf8, 0xe2, 0xc9,
+ 0xad, 0x2b, 0x4e, 0x24, 0x57, 0x13, 0xd9, 0xd5, 0x9b, 0x97, 0x82, 0xe2, 0x8e,
+ 0x0f, 0x35, 0x93, 0x61, 0xff, 0x2a, 0x0d, 0x10, 0xb9, 0x66, 0x56, 0x73,
+ ]
+ ),
+ test_case!(
+ [
+ 0x0f, 0x15, 0x7f, 0x02, 0x2d, 0x99, 0xc3, 0x22, 0x4c, 0xac, 0xa9, 0xf5, 0xa5,
+ 0x21, 0x80, 0x50, 0x54, 0xc1, 0x37, 0x96, 0x46, 0xde, 0xda, 0x2e, 0x5d, 0xcf,
+ 0xcb, 0x29, 0x2f, 0xc3, 0x01, 0x2d, 0x88, 0x4a, 0xbf, 0xc1, 0xf0, 0xd7, 0x71,
+ 0x41, 0x18, 0x1d, 0xe5, 0x28, 0xba, 0x3c, 0x45, 0x8b, 0xd5, 0x83, 0x92, 0x1a,
+ 0xab, 0xd3, 0x62, 0x45, 0xd1, 0xb2, 0xd8, 0x57, 0x93, 0xac, 0x8d, 0x61, 0x7a,
+ 0xa0,
+ ],
+ [
+ 0xe0, 0x88, 0xda, 0x90, 0x19, 0x76, 0x9d, 0xab, 0x80, 0xaa, 0x7e, 0x76, 0x10,
+ 0x37, 0x1a, 0x60, 0x23, 0x15, 0xa5, 0x7d,
+ ],
+ [
+ 0xbf, 0x6e, 0x16, 0x4b, 0x81, 0x52, 0x5b, 0x39, 0xac, 0xeb, 0xda, 0x54, 0xdd,
+ 0x6a, 0xd6, 0xee, 0xb4, 0x52, 0x3e, 0xfd, 0x65, 0x3f, 0xfd, 0x2f, 0x8f, 0xcd,
+ 0x18, 0x2f, 0x61, 0xa9, 0xfe, 0x7a,
+ ],
+ [
+ 0x8b, 0x0f, 0x73, 0x49, 0xa5, 0x7a, 0x8b, 0x6a, 0xae, 0x7e, 0xa1, 0xda, 0x63,
+ 0x10, 0x9c, 0xb5, 0x29, 0x5a, 0xd7, 0x34, 0xbf, 0x5e, 0x29, 0x46, 0x4d, 0x9c,
+ 0xd3, 0x5c, 0x62, 0x43, 0x7a, 0xa9, 0xd6, 0x85, 0xe7, 0x36, 0xc5, 0x51, 0x98,
+ 0xb1, 0x1f, 0xb4, 0xff, 0x28, 0xc3, 0x6a, 0xd6, 0x03,
+ ],
+ [
+ 0x4f, 0xc9, 0x98, 0x80, 0x67, 0xc4, 0x33, 0x99, 0x5f, 0x59, 0xfe, 0xe7, 0xe3,
+ 0xf6, 0x6f, 0xbf, 0xb1, 0x5d, 0x38, 0x58, 0x16, 0xff, 0xa6, 0xd8, 0x98, 0x75,
+ 0xa0, 0xd0, 0x0c, 0x99, 0xdb, 0x4b, 0x40, 0x23, 0x13, 0x65, 0x33, 0x31, 0x9e,
+ 0x58, 0x95, 0xa5, 0x8d, 0x9e, 0x3d, 0x9a, 0x57, 0x82, 0x73, 0x96, 0x9f, 0x2c,
+ 0xf4, 0x29, 0x04, 0x5e, 0x44, 0xbf, 0xcf, 0x64, 0x5d, 0x8d, 0xf9, 0x99,
+ ]
+ ),
+ test_case!(
+ [
+ 0x79, 0x51, 0xb5, 0x57, 0x9f, 0x24, 0x79, 0xaa, 0xeb, 0x62, 0xeb, 0xbb, 0x66,
+ 0xe9, 0x03, 0x96, 0x4c, 0x71, 0x32, 0xa4, 0x1b, 0x0b, 0x93, 0xca, 0x82, 0x12,
+ 0x75, 0x80, 0x62, 0x04, 0x64, 0x85, 0x35, 0x80, 0xe2, 0x0a, 0xb2, 0x6d, 0xbd,
+ 0xc0, 0x6c, 0xd3, 0x54, 0xc8, 0xc9, 0xc6, 0x66, 0x31, 0xa1, 0xc8, 0xb1, 0x0e,
+ 0x5f, 0xf9, 0x16, 0xe9, 0x0a, 0xec, 0xf9, 0x10, 0x94, 0xd7, 0x0e, 0xc5, 0x8e,
+ 0x9a, 0x02,
+ ],
+ [
+ 0x74, 0x81, 0x61, 0x52, 0xc0, 0xeb, 0x65, 0x14, 0xbe, 0xba, 0x4f, 0x43, 0x3f,
+ 0x1f, 0x02, 0x36, 0x9b, 0xb5, 0x00, 0x4a,
+ ],
+ [
+ 0xb4, 0xfd, 0xd8, 0xb5, 0x2f, 0x20, 0x82, 0x00, 0x20, 0xaf, 0x65, 0x20, 0xf0,
+ 0x6e, 0x17, 0x7c, 0x10, 0x3d, 0xe5, 0x2b, 0x68, 0x11, 0x87, 0x50, 0xb5, 0x26,
+ 0xbd, 0x60, 0x36, 0x85, 0xc8, 0xfb,
+ ],
+ [
+ 0xfb, 0xb9, 0x59, 0x12, 0xb3, 0x72, 0x55, 0x4a, 0x95, 0xcf, 0x6a, 0x87, 0xdc,
+ 0x45, 0xa9, 0xa4, 0x03, 0x9b, 0x89, 0x6f, 0xf1, 0xe8, 0x62, 0x55, 0x39, 0x21,
+ 0x73, 0x6a, 0xfe, 0xd8, 0x1f, 0xf1, 0xd4, 0x6c, 0x90, 0x40, 0xaf, 0x1f, 0xca,
+ 0x75, 0xe7, 0xb3, 0x94, 0xe2, 0xe9, 0x1e, 0x0b, 0x47,
+ ],
+ [
+ 0x0e, 0x4a, 0x98, 0x6e, 0x36, 0x17, 0x2a, 0x2a, 0x46, 0xdb, 0x50, 0x17, 0xef,
+ 0x56, 0xe2, 0x18, 0xdc, 0x4b, 0x98, 0x44, 0x7a, 0xae, 0x7f, 0x73, 0xf6, 0x4c,
+ 0x79, 0xa1, 0x21, 0x10, 0x97, 0x32, 0x16, 0xea, 0x9b, 0x1d, 0xd6, 0x15, 0x64,
+ 0xd3, 0x9c, 0xc9, 0xf7, 0xc9, 0x47, 0xfe, 0x61, 0xe7, 0x8b, 0xdf, 0x31, 0xb1,
+ 0x0c, 0x52, 0xb3, 0xc2, 0x93, 0x77, 0x51, 0x8e, 0x10, 0xe5, 0x2b, 0x9b,
+ ]
+ ),
+ test_case!(
+ [
+ 0x59, 0x79, 0xfc, 0xb2, 0x37, 0x18, 0xfc, 0x85, 0xe5, 0x0f, 0x54, 0x46, 0xbc,
+ 0x64, 0x27, 0xed, 0xcb, 0xe2, 0x1b, 0x49, 0x58, 0x41, 0xee, 0x23, 0x63, 0x3f,
+ 0xc2, 0xe9, 0x19, 0xc8, 0x25, 0x8d, 0x23, 0x3b, 0x02, 0xb3, 0x34, 0xb8, 0x49,
+ 0xb8, 0xbb, 0xd1, 0xa2, 0x59, 0x77, 0x6c, 0x22, 0xc5, 0x2a, 0x64, 0xca, 0x2e,
+ 0xad, 0x48, 0x53, 0x03, 0x03, 0x1e, 0xe5, 0x29, 0x9d, 0x0e, 0xec, 0x36, 0x34,
+ 0x30, 0xf2, 0x95,
+ ],
+ [
+ 0x21, 0x23, 0xbf, 0x94, 0x51, 0x7c, 0xdf, 0xa5, 0x97, 0x8c, 0x89, 0x7f, 0xbe,
+ 0xc7, 0xab, 0x99, 0x06, 0x08, 0xbf, 0xfa,
+ ],
+ [
+ 0xb7, 0x92, 0xa5, 0xea, 0xda, 0xfb, 0x4e, 0x0c, 0x9b, 0x15, 0x6c, 0x7e, 0x75,
+ 0x72, 0x52, 0xca, 0xa7, 0xdf, 0xe1, 0x1b, 0x0d, 0xd7, 0x43, 0xe9, 0xd0, 0x75,
+ 0x19, 0xea, 0xac, 0x8f, 0x7d, 0x56,
+ ],
+ [
+ 0x2c, 0xa2, 0x85, 0x3e, 0x3a, 0x52, 0xab, 0xe3, 0xdf, 0x87, 0x93, 0x85, 0xe8,
+ 0xbf, 0xad, 0x07, 0x48, 0x40, 0xfc, 0x1a, 0x11, 0x27, 0x1e, 0xed, 0xed, 0xad,
+ 0xd1, 0x6e, 0xa1, 0xd9, 0x5c, 0xb4, 0xa5, 0x85, 0x5f, 0xf7, 0x98, 0xf9, 0xc9,
+ 0xd8, 0x35, 0xbc, 0xd0, 0x91, 0x82, 0xa2, 0x3b, 0x10,
+ ],
+ [
+ 0x94, 0xde, 0x58, 0x98, 0x46, 0x5a, 0xd7, 0x41, 0x2b, 0x37, 0x1b, 0x71, 0xa4,
+ 0x43, 0x97, 0x86, 0x4b, 0x1f, 0xa7, 0x65, 0x3c, 0x64, 0x2e, 0x2a, 0x44, 0xc7,
+ 0x77, 0x31, 0xdc, 0x6a, 0x72, 0xc2, 0xb1, 0x8b, 0x8f, 0xff, 0x29, 0xb6, 0x3e,
+ 0xb9, 0x11, 0x43, 0x3f, 0x56, 0x57, 0xa4, 0x0c, 0xc4, 0xd3, 0x24, 0x20, 0xd3,
+ 0x9c, 0xf1, 0x62, 0xf2, 0x19, 0x27, 0x93, 0x7a, 0xdb, 0x64, 0x30, 0x81,
+ ]
+ ),
+ test_case!(
+ [
+ 0x79, 0xe5, 0x5f, 0x2e, 0x88, 0x2a, 0x37, 0xe6, 0xdf, 0xc8, 0x02, 0x07, 0x94,
+ 0x27, 0xd8, 0x7e, 0x46, 0xfc, 0xa4, 0x3e, 0x5d, 0x4d, 0x9a, 0xfc, 0x2f, 0xc5,
+ 0x8c, 0x80, 0xcc, 0xc9, 0x0b, 0x6e, 0xb2, 0x97, 0xbb, 0xbc, 0x55, 0xe7, 0x62,
+ 0x13, 0x23, 0x28, 0x4a, 0x88, 0xbe, 0x59, 0x7b, 0x31, 0x43, 0x90, 0xc6, 0xbb,
+ 0xc7, 0x20, 0x6c, 0x2b, 0x88, 0xb1, 0x4d, 0x1b, 0xd2, 0x22, 0x3d, 0x3e, 0xa9,
+ 0x23, 0xbf, 0xff, 0x19,
+ ],
+ [
+ 0x59, 0x6d, 0xfd, 0x02, 0xf7, 0x77, 0x3f, 0x2c, 0x51, 0x95, 0xb2, 0xe9, 0x82,
+ 0xfc, 0x1e, 0x77, 0x56, 0x0b, 0x84, 0x35,
+ ],
+ [
+ 0xd5, 0x83, 0xa5, 0x88, 0x90, 0x17, 0x48, 0x53, 0x42, 0x43, 0xd4, 0xfa, 0x7f,
+ 0xfe, 0x0e, 0x61, 0xac, 0xe5, 0x90, 0x84, 0xef, 0x97, 0x11, 0x16, 0x3d, 0x83,
+ 0xfd, 0x95, 0xa7, 0x4d, 0xf5, 0x1c,
+ ],
+ [
+ 0x59, 0x48, 0x81, 0xcd, 0x61, 0x10, 0xae, 0x7b, 0x67, 0x60, 0x03, 0x3d, 0xd1,
+ 0x3e, 0x11, 0x56, 0xf6, 0x89, 0x19, 0x68, 0x7d, 0xc0, 0x99, 0xdf, 0x24, 0x17,
+ 0xe8, 0x25, 0x68, 0x44, 0x3d, 0x36, 0xca, 0x6e, 0x6d, 0x83, 0xb2, 0x2b, 0x33,
+ 0x54, 0x9a, 0x46, 0x31, 0x7c, 0x3a, 0xea, 0x7a, 0x0a,
+ ],
+ [
+ 0x24, 0x2a, 0x04, 0x80, 0xbc, 0x00, 0xc8, 0x92, 0xf6, 0x73, 0x10, 0x28, 0x18,
+ 0xbf, 0xca, 0xe1, 0x54, 0xab, 0x5e, 0x4b, 0xff, 0x9a, 0x84, 0xdc, 0x56, 0x0d,
+ 0xb3, 0x69, 0xef, 0x3b, 0x5d, 0x9d, 0xf2, 0xba, 0x1e, 0x92, 0x2e, 0x29, 0xfe,
+ 0x9d, 0x65, 0xfb, 0xd8, 0xa0, 0x7b, 0x8e, 0xaa, 0x3d, 0x5b, 0x95, 0x82, 0xdb,
+ 0xa5, 0x1e, 0x99, 0x50, 0x24, 0x68, 0x4b, 0xed, 0xdc, 0xf6, 0x31, 0x35,
+ ]
+ ),
+ test_case!(
+ [
+ 0xea, 0x15, 0xf8, 0xc4, 0x41, 0xd0, 0xba, 0xf1, 0x7c, 0x80, 0x0e, 0x0d, 0x5a,
+ 0x9d, 0xb4, 0x1b, 0x98, 0x24, 0x16, 0x45, 0x24, 0x5d, 0x7e, 0x5a, 0xc9, 0xd2,
+ 0xd8, 0xb7, 0x30, 0x8f, 0xc4, 0xdd, 0x89, 0xf8, 0xa8, 0x75, 0x4b, 0xfd, 0xc5,
+ 0x7b, 0x41, 0xb5, 0x50, 0xff, 0x08, 0xf2, 0x2a, 0x47, 0xef, 0x17, 0xa9, 0x9c,
+ 0xf7, 0x13, 0x0c, 0x73, 0xe5, 0xa8, 0x4d, 0xa0, 0xb1, 0x2d, 0x90, 0x4c, 0x44,
+ 0x09, 0xf9, 0x1c, 0xa5, 0x92,
+ ],
+ [
+ 0xea, 0x4b, 0xf7, 0x90, 0x5c, 0xe9, 0xed, 0x8c, 0xcd, 0xae, 0x14, 0x26, 0x2d,
+ 0xc1, 0xa8, 0x99, 0xb3, 0x82, 0x02, 0x8f,
+ ],
+ [
+ 0x57, 0x79, 0x6d, 0x31, 0x43, 0x87, 0xa9, 0xd7, 0x6b, 0xbe, 0x62, 0xf9, 0xa4,
+ 0xb2, 0x1f, 0x60, 0xd7, 0x20, 0xdc, 0x17, 0x72, 0x75, 0x66, 0x4f, 0xbb, 0x9f,
+ 0x30, 0xb5, 0x38, 0x3c, 0x7f, 0x8c,
+ ],
+ [
+ 0x2a, 0x2f, 0x1e, 0x3e, 0x00, 0xe1, 0x61, 0xd9, 0xbd, 0xf0, 0x02, 0x50, 0xa1,
+ 0xe9, 0x42, 0x97, 0x4e, 0xfd, 0x32, 0x99, 0xc2, 0xf3, 0x28, 0x39, 0x4c, 0x0a,
+ 0xe5, 0x8d, 0x30, 0xdd, 0x39, 0x9b, 0xd6, 0x97, 0x2e, 0x9e, 0xdb, 0x88, 0x85,
+ 0x1b, 0xff, 0xb1, 0x80, 0x80, 0x2e, 0xda, 0x34, 0x10,
+ ],
+ [
+ 0xd3, 0x68, 0x52, 0xa7, 0xfc, 0x77, 0x64, 0x93, 0xa4, 0x8f, 0x48, 0x18, 0xc9,
+ 0x76, 0x01, 0x4a, 0xaa, 0x6f, 0x99, 0x8a, 0xad, 0x02, 0xf0, 0x62, 0x9a, 0xfc,
+ 0xa2, 0x31, 0xdf, 0x7d, 0x2d, 0x27, 0x10, 0x42, 0xc4, 0x97, 0x6e, 0x96, 0x0b,
+ 0x01, 0x67, 0xaf, 0x41, 0x44, 0x3d, 0x4d, 0xd6, 0xb4, 0xdd, 0x43, 0xcc, 0xa1,
+ 0xc5, 0x15, 0x83, 0x95, 0x41, 0x24, 0x27, 0x13, 0xb3, 0xf1, 0x76, 0x7b,
+ ]
+ ),
+ test_case!(
+ [
+ 0x27, 0xf0, 0x30, 0x3a, 0x41, 0x0f, 0xaa, 0xf8, 0x1c, 0x0f, 0xb9, 0x2d, 0x1d,
+ 0x76, 0x02, 0x23, 0x2c, 0x1c, 0x98, 0x97, 0xb2, 0x44, 0xef, 0xb7, 0xd6, 0x24,
+ 0xd2, 0xfb, 0x39, 0x7e, 0xfd, 0x12, 0x4f, 0x63, 0x3a, 0x40, 0xd9, 0x24, 0x35,
+ 0x7e, 0x52, 0x33, 0x93, 0x82, 0xa0, 0x3d, 0x79, 0xc9, 0xea, 0x06, 0x8c, 0x05,
+ 0xab, 0x0d, 0xc7, 0x16, 0xc2, 0x81, 0x4f, 0x54, 0xe5, 0x6b, 0xda, 0x81, 0x2e,
+ 0xc5, 0xfd, 0xe9, 0x1a, 0x4c, 0x06,
+ ],
+ [
+ 0x50, 0xad, 0x70, 0xee, 0x51, 0xde, 0xcd, 0x6c, 0xdf, 0xa5, 0x8c, 0xcf, 0x28,
+ 0xb6, 0x49, 0xfc, 0xf5, 0x0c, 0xca, 0xa5,
+ ],
+ [
+ 0x9e, 0x9e, 0xb0, 0xe5, 0xa2, 0x66, 0x86, 0x99, 0x8e, 0x09, 0x88, 0xb3, 0xf0,
+ 0x83, 0x36, 0x81, 0xf8, 0xd3, 0x42, 0xe8, 0xbc, 0xc0, 0x26, 0x4b, 0x7b, 0xd5,
+ 0xe0, 0x54, 0x9f, 0x6f, 0x8b, 0xe2,
+ ],
+ [
+ 0x59, 0x45, 0xc0, 0xa3, 0x45, 0x64, 0x92, 0xc6, 0x7d, 0x3e, 0x21, 0xce, 0x7c,
+ 0x05, 0x80, 0xc9, 0xa2, 0x55, 0x2e, 0x80, 0x82, 0x35, 0x2f, 0x6f, 0xc1, 0x9c,
+ 0xb0, 0xba, 0x78, 0xd6, 0xd9, 0xe9, 0x84, 0x1a, 0x52, 0xc1, 0xa3, 0xe8, 0xf9,
+ 0x2d, 0xcc, 0x20, 0x9f, 0x5e, 0xe1, 0x23, 0xb5, 0xc0,
+ ],
+ [
+ 0x29, 0x5f, 0xa2, 0xa1, 0x6d, 0x08, 0xdd, 0xac, 0xe1, 0x64, 0x8b, 0x75, 0x79,
+ 0x6d, 0x3a, 0x33, 0x8f, 0xff, 0xd3, 0x22, 0x98, 0xd1, 0xf2, 0xcb, 0xc6, 0x35,
+ 0x30, 0xe1, 0x22, 0xd2, 0xb9, 0x77, 0x0c, 0x01, 0x50, 0x4c, 0x86, 0x0a, 0x36,
+ 0x85, 0x94, 0xb1, 0x60, 0x38, 0xf6, 0x74, 0x4b, 0x98, 0xff, 0xc8, 0x89, 0x31,
+ 0xb2, 0x50, 0x3d, 0x26, 0xed, 0x47, 0x05, 0xa5, 0xf1, 0xb8, 0xdf, 0x7f,
+ ]
+ ),
+ test_case!(
+ [
+ 0xd1, 0x00, 0x9f, 0x11, 0x7e, 0xaf, 0x68, 0x58, 0x33, 0xdd, 0x3b, 0x32, 0x0a,
+ 0xfb, 0x79, 0xed, 0x14, 0x78, 0xa9, 0x79, 0xe0, 0xfd, 0x49, 0x41, 0x67, 0xe1,
+ 0x8d, 0x7a, 0x0e, 0xcb, 0x8b, 0xc2, 0xd6, 0xa9, 0xfc, 0xd6, 0x7d, 0xbf, 0x62,
+ 0x34, 0xe6, 0x30, 0x55, 0xb7, 0xda, 0xf1, 0x06, 0x9c, 0x5a, 0x78, 0xa5, 0x2e,
+ 0xdb, 0xf0, 0x9d, 0x92, 0xd3, 0xa1, 0x85, 0x1d, 0x35, 0xf0, 0x38, 0xd9, 0x65,
+ 0x1e, 0x87, 0x78, 0xd9, 0x07, 0x14, 0x70,
+ ],
+ [
+ 0xfd, 0x57, 0xd5, 0xd3, 0x5d, 0x77, 0xcd, 0x32, 0x1b, 0x04, 0xab, 0xd3, 0x1a,
+ 0xb0, 0x9a, 0xed, 0x52, 0xe3, 0x88, 0x56,
+ ],
+ [
+ 0x24, 0x26, 0x23, 0xa6, 0x2e, 0xb2, 0x68, 0x6f, 0x7d, 0x5f, 0xc0, 0x46, 0x65,
+ 0x73, 0xe7, 0x59, 0x1c, 0xfc, 0xec, 0x41, 0xc8, 0x79, 0x05, 0x92, 0xf9, 0x17,
+ 0xb2, 0xc1, 0xd2, 0xee, 0xd6, 0xa2,
+ ],
+ [
+ 0xd1, 0xdc, 0x32, 0x55, 0x1a, 0xe0, 0xf3, 0x74, 0x74, 0x0f, 0x4f, 0x16, 0xdc,
+ 0x3d, 0xf1, 0xeb, 0x85, 0x58, 0x8c, 0xa6, 0x18, 0x82, 0x00, 0xb3, 0xa6, 0x6b,
+ 0x20, 0xd8, 0x01, 0x65, 0x81, 0xa2, 0xb7, 0x81, 0x13, 0x34, 0x0d, 0x54, 0xb1,
+ 0x91, 0xf9, 0x29, 0x17, 0xe7, 0x99, 0x46, 0xab, 0xd0,
+ ],
+ [
+ 0x04, 0x9f, 0x32, 0x34, 0x1a, 0xff, 0x82, 0x14, 0x63, 0xf7, 0x4f, 0x86, 0x63,
+ 0xd7, 0xca, 0xad, 0xe7, 0x77, 0x60, 0x4f, 0xb4, 0x22, 0xe4, 0x9a, 0xba, 0x07,
+ 0xa7, 0x03, 0x3d, 0x30, 0xd1, 0x9e, 0xcc, 0x05, 0x3e, 0x0d, 0x32, 0xd6, 0xb6,
+ 0xdc, 0x35, 0xc7, 0x6d, 0xd3, 0x9e, 0x8d, 0xb2, 0x90, 0x3a, 0xe1, 0xf3, 0x9a,
+ 0x57, 0xd2, 0x85, 0x1f, 0xd4, 0xab, 0x01, 0x03, 0xe3, 0xa0, 0x81, 0x39,
+ ]
+ ),
+ test_case!(
+ [
+ 0x19, 0x5a, 0xf7, 0xd9, 0xa3, 0x3b, 0x42, 0x6d, 0x16, 0xaa, 0x36, 0x33, 0x18,
+ 0x91, 0x5c, 0xe3, 0x13, 0x7b, 0x12, 0xa9, 0x46, 0x12, 0x2e, 0x85, 0x5c, 0x89,
+ 0xdf, 0xde, 0x67, 0xde, 0xe8, 0x16, 0xa2, 0x8d, 0x05, 0x5f, 0xcb, 0x56, 0x69,
+ 0x68, 0xb3, 0xd7, 0x54, 0xc4, 0x22, 0xf9, 0x8e, 0x3b, 0x5b, 0xea, 0x8f, 0xfe,
+ 0x73, 0x1d, 0x83, 0x77, 0xc8, 0xc0, 0x27, 0x7d, 0x04, 0xfd, 0x4d, 0x0a, 0x4a,
+ 0xb7, 0xfe, 0xa6, 0x00, 0x66, 0xf4, 0x9a, 0xd3,
+ ],
+ [
+ 0xce, 0xf5, 0xb7, 0xa3, 0xa5, 0xc1, 0xfe, 0xa4, 0x79, 0xbb, 0xf9, 0x56, 0x39,
+ 0xed, 0x02, 0x93, 0xe0, 0x15, 0x64, 0x64,
+ ],
+ [
+ 0xe0, 0x14, 0xd9, 0xd7, 0xa1, 0xc2, 0x23, 0x96, 0xa5, 0xf9, 0xb0, 0x28, 0xb5,
+ 0x67, 0xc1, 0x5d, 0xe0, 0x89, 0x76, 0x36, 0x0b, 0x6c, 0x63, 0x8a, 0xc4, 0xca,
+ 0x76, 0xb3, 0x16, 0xb5, 0xa7, 0x25,
+ ],
+ [
+ 0x4c, 0x58, 0xfd, 0x63, 0x23, 0x52, 0x75, 0xcb, 0x66, 0x2f, 0xdb, 0xff, 0x73,
+ 0x0e, 0x54, 0x8c, 0xaf, 0x2e, 0x35, 0x6a, 0xd9, 0xf6, 0x16, 0x39, 0xfe, 0x81,
+ 0x09, 0x08, 0x3c, 0x68, 0x96, 0x1b, 0x84, 0x0b, 0xb7, 0x9f, 0x06, 0x61, 0xa9,
+ 0x87, 0x80, 0xec, 0x14, 0xd4, 0xee, 0x78, 0x05, 0x55,
+ ],
+ [
+ 0xc7, 0x17, 0x5c, 0x64, 0x8e, 0x4b, 0x28, 0xe1, 0xb3, 0x9a, 0xab, 0xe0, 0xd0,
+ 0x5d, 0xed, 0x99, 0x3f, 0xa3, 0xe5, 0x6b, 0x93, 0x25, 0x37, 0x81, 0xac, 0x7d,
+ 0x33, 0x0b, 0x33, 0xe2, 0xe3, 0x62, 0xc5, 0x14, 0x11, 0xee, 0x02, 0x71, 0x11,
+ 0xe4, 0x3c, 0x52, 0x42, 0xa0, 0xb6, 0xa9, 0x63, 0x58, 0xfc, 0xef, 0x37, 0x94,
+ 0x9b, 0x4c, 0xf8, 0xe1, 0x40, 0x28, 0x2f, 0x9e, 0xa7, 0x1e, 0x84, 0x3f,
+ ]
+ ),
+ test_case!(
+ [
+ 0x81, 0x5e, 0xe5, 0x67, 0x65, 0x1b, 0x25, 0x7b, 0x71, 0x3b, 0xc7, 0xb7, 0xe1,
+ 0xec, 0x8a, 0x69, 0x08, 0x79, 0x11, 0x59, 0x9d, 0xdf, 0x12, 0xf4, 0x0e, 0x27,
+ 0x7e, 0x73, 0x25, 0x8c, 0x61, 0xde, 0x3a, 0xfe, 0xaf, 0xa7, 0x62, 0xc9, 0x02,
+ 0x18, 0x3b, 0x85, 0x2f, 0x9f, 0xf0, 0xe6, 0x0a, 0x81, 0xd2, 0x59, 0x07, 0x78,
+ 0xfe, 0x7a, 0x8b, 0x4e, 0x4a, 0x7a, 0xec, 0xb9, 0x05, 0x84, 0xbb, 0x14, 0xfb,
+ 0x13, 0x5b, 0xfc, 0xf7, 0xb0, 0x6d, 0xb7, 0x68, 0x5d,
+ ],
+ [
+ 0xf1, 0xa1, 0x0a, 0x51, 0x2b, 0xa7, 0xdf, 0x1a, 0x35, 0x77, 0x31, 0x28, 0x10,
+ 0x07, 0xa5, 0x7d, 0x64, 0x82, 0x91, 0x45,
+ ],
+ [
+ 0x8d, 0x66, 0x60, 0x7e, 0xfe, 0x75, 0x63, 0x3e, 0x3b, 0xdb, 0xec, 0x42, 0x08,
+ 0xec, 0xdc, 0x93, 0x88, 0xb4, 0x64, 0xb4, 0xf1, 0x60, 0x14, 0x41, 0x01, 0x17,
+ 0x4b, 0x9b, 0x5e, 0x70, 0xc0, 0xae,
+ ],
+ [
+ 0x2e, 0xab, 0xbb, 0x49, 0x93, 0x2c, 0xee, 0x76, 0xbf, 0x1c, 0x71, 0x63, 0x48,
+ 0x89, 0xa8, 0xd2, 0xc9, 0xdc, 0xd6, 0x13, 0xe8, 0xde, 0x28, 0xfc, 0xce, 0x2e,
+ 0x01, 0xf2, 0x1f, 0x08, 0xdf, 0x17, 0x97, 0x94, 0xfd, 0x38, 0x92, 0xc5, 0x19,
+ 0x48, 0x77, 0xb7, 0xec, 0xf2, 0x9d, 0x1c, 0x27, 0xf5,
+ ],
+ [
+ 0x5f, 0x96, 0xcc, 0x97, 0x45, 0x83, 0xe1, 0xa2, 0xcc, 0xcf, 0x63, 0xa4, 0x2f,
+ 0x9a, 0x0d, 0x75, 0x04, 0xb2, 0xa6, 0xd8, 0x27, 0x36, 0xd8, 0x7e, 0x65, 0x2e,
+ 0x22, 0x76, 0x69, 0x20, 0x78, 0x9e, 0x7f, 0x4b, 0xeb, 0xae, 0x7f, 0x8f, 0xb3,
+ 0x13, 0xe0, 0x67, 0xd4, 0xc5, 0xef, 0xd2, 0x8d, 0x6c, 0x7a, 0xbe, 0xb7, 0xb4,
+ 0xf3, 0x66, 0xd6, 0xbd, 0xcb, 0xd1, 0x6d, 0x6b, 0x0e, 0x4b, 0x75, 0xaa,
+ ]
+ ),
+ test_case!(
+ [
+ 0x8e, 0x8a, 0x55, 0x1f, 0xb8, 0x66, 0xe1, 0x18, 0xc4, 0x92, 0x47, 0x5c, 0x41,
+ 0x80, 0x21, 0xa4, 0xc9, 0xf7, 0x13, 0x14, 0x61, 0x26, 0xf2, 0x8d, 0x7f, 0xf6,
+ 0x08, 0x49, 0x4c, 0x8e, 0xb2, 0x2c, 0x60, 0x99, 0x0c, 0xaf, 0x08, 0xf6, 0xbc,
+ 0xdf, 0xf0, 0x64, 0x99, 0x17, 0xda, 0x50, 0x0b, 0x00, 0xca, 0x15, 0x57, 0xe6,
+ 0x78, 0x1b, 0x6a, 0x40, 0x0d, 0x84, 0x88, 0xc5, 0x5c, 0x91, 0xa5, 0x86, 0x71,
+ 0x9c, 0x3d, 0x96, 0x67, 0xf4, 0x00, 0x41, 0x50, 0xea, 0x62,
+ ],
+ [
+ 0x06, 0x2a, 0x05, 0x5b, 0x5f, 0x3f, 0x45, 0xd5, 0x80, 0x1b, 0xfa, 0xcc, 0xd1,
+ 0x0c, 0x3d, 0x24, 0xf0, 0x6c, 0x33, 0xb2,
+ ],
+ [
+ 0xce, 0xf0, 0x26, 0xf3, 0xe2, 0x46, 0x6e, 0x18, 0xe2, 0xab, 0x50, 0x2f, 0x08,
+ 0x61, 0x7c, 0xb4, 0x9e, 0x10, 0x0a, 0xb4, 0x93, 0xe0, 0x60, 0xa2, 0x01, 0xe7,
+ 0xf1, 0xc8, 0x68, 0xf2, 0xde, 0xf4,
+ ],
+ [
+ 0x16, 0x3c, 0xaa, 0xe5, 0x7d, 0x1a, 0xdb, 0xdf, 0xc8, 0xad, 0xd9, 0x83, 0x2a,
+ 0x1f, 0x00, 0x8a, 0x28, 0x17, 0xf0, 0x2d, 0x49, 0x73, 0x21, 0xf3, 0x5b, 0x90,
+ 0x8b, 0xee, 0x0b, 0xcc, 0x97, 0x5e, 0x73, 0xc5, 0x50, 0x07, 0x6e, 0x79, 0x3b,
+ 0x0b, 0xad, 0xd3, 0x8c, 0x84, 0xa9, 0x24, 0xea, 0xe2,
+ ],
+ [
+ 0x4b, 0x4c, 0xd1, 0x1a, 0x19, 0x49, 0x9d, 0xb0, 0x2a, 0x81, 0x6c, 0x5c, 0xcf,
+ 0xa8, 0x20, 0xd4, 0x39, 0x75, 0x8b, 0xe4, 0xe8, 0xfd, 0x49, 0x43, 0x8a, 0x65,
+ 0x50, 0xb9, 0xa8, 0x0f, 0xd1, 0xb9, 0xde, 0x2c, 0x6a, 0x83, 0x2d, 0x29, 0x8b,
+ 0x54, 0xea, 0xc0, 0xb2, 0x83, 0x85, 0x84, 0x67, 0x7f, 0xe7, 0x93, 0x9f, 0xc2,
+ 0x43, 0x23, 0x63, 0x78, 0xf3, 0xc9, 0x3c, 0x40, 0x90, 0xad, 0xff, 0xa2,
+ ]
+ ),
+ test_case!(
+ [
+ 0x34, 0x4b, 0xff, 0x4b, 0x2c, 0x8d, 0x1d, 0x4e, 0xff, 0x62, 0xbd, 0xa1, 0x3d,
+ 0xac, 0x35, 0x6f, 0xb8, 0xd9, 0x77, 0x0e, 0x19, 0x00, 0x31, 0x66, 0x24, 0xaf,
+ 0x19, 0x51, 0xa8, 0x63, 0xaf, 0xff, 0x4b, 0x34, 0x55, 0x6b, 0x2f, 0x8d, 0x60,
+ 0x72, 0xcc, 0xc9, 0x56, 0x24, 0x82, 0x86, 0xe3, 0xac, 0xe5, 0x78, 0x46, 0xdd,
+ 0x80, 0x07, 0x74, 0xe1, 0x76, 0x26, 0xb5, 0x37, 0x9b, 0xe8, 0x8c, 0x78, 0xe2,
+ 0x34, 0x90, 0x6f, 0x47, 0x98, 0x16, 0x6f, 0xee, 0x9d, 0x67, 0x28,
+ ],
+ [
+ 0x67, 0x40, 0x33, 0x76, 0xfd, 0x7c, 0xee, 0xb6, 0xdf, 0x90, 0x4e, 0xe0, 0xcd,
+ 0xca, 0x0c, 0xb7, 0xf9, 0x8b, 0x98, 0xd1,
+ ],
+ [
+ 0xab, 0xdc, 0x9c, 0xfd, 0xb0, 0x9a, 0xb0, 0xf8, 0x3c, 0xae, 0x37, 0x52, 0xae,
+ 0x67, 0x11, 0xfc, 0x3c, 0xcc, 0x45, 0x25, 0x5b, 0x92, 0x05, 0x7e, 0xc7, 0x4a,
+ 0x8f, 0x11, 0xd9, 0x48, 0xa1, 0x4f,
+ ],
+ [
+ 0xed, 0x7b, 0x7b, 0x62, 0xe6, 0x5e, 0x02, 0x22, 0xbc, 0xb8, 0x1f, 0xe9, 0x71,
+ 0x15, 0x9d, 0x7b, 0x29, 0xc7, 0x24, 0xf8, 0xfd, 0xc0, 0x8c, 0xb2, 0xdd, 0x67,
+ 0x56, 0x02, 0x01, 0xfe, 0xba, 0xc2, 0xc9, 0xdb, 0x2e, 0xf5, 0xf2, 0xcb, 0x0b,
+ 0x8d, 0xe8, 0x4b, 0x31, 0x82, 0x2e, 0x00, 0x12, 0x14,
+ ],
+ [
+ 0xfa, 0xca, 0xb8, 0x26, 0x2c, 0x41, 0x60, 0x1f, 0xf5, 0xa6, 0xef, 0x53, 0x53,
+ 0xdf, 0xb2, 0xa5, 0x19, 0xcb, 0xa3, 0x13, 0xfa, 0x65, 0x53, 0x26, 0x43, 0x73,
+ 0xdc, 0x7d, 0xbc, 0x2f, 0xd7, 0x3b, 0xb1, 0xac, 0xb5, 0x85, 0x0d, 0x5c, 0x1a,
+ 0x6f, 0x53, 0xe5, 0x44, 0xbb, 0xc5, 0x68, 0xa5, 0xd5, 0xdc, 0xb8, 0xa8, 0xff,
+ 0xff, 0x5e, 0x2f, 0x75, 0xa6, 0xdf, 0x4b, 0xcc, 0xbb, 0xfa, 0xa4, 0x9d,
+ ]
+ ),
+ test_case!(
+ [
+ 0xf5, 0xc5, 0x46, 0xed, 0x3e, 0x48, 0x33, 0xac, 0x25, 0x5b, 0x22, 0x6f, 0xfb,
+ 0x06, 0x0d, 0xc6, 0xa5, 0x92, 0xbc, 0x36, 0x0d, 0xb5, 0x74, 0x5a, 0x76, 0xe9,
+ 0x07, 0x17, 0xd9, 0x4d, 0xbd, 0xe3, 0x96, 0x95, 0xb0, 0x82, 0x6c, 0x20, 0x1a,
+ 0x14, 0x69, 0x6c, 0x6a, 0x63, 0x4b, 0x1b, 0x01, 0x11, 0xf1, 0x16, 0x80, 0xe5,
+ 0x61, 0xc5, 0x6a, 0x61, 0x2a, 0x66, 0x37, 0x78, 0x81, 0x10, 0x90, 0x07, 0x92,
+ 0x20, 0x4e, 0xe0, 0xc7, 0x82, 0x90, 0x19, 0x43, 0x4b, 0xa8, 0x47, 0x59,
+ ],
+ [
+ 0x58, 0x95, 0xf1, 0x4c, 0x60, 0xed, 0x9f, 0xa5, 0xdf, 0xd7, 0xe6, 0x70, 0x96,
+ 0xa1, 0x8f, 0xce, 0xac, 0x01, 0xba, 0x84,
+ ],
+ [
+ 0x20, 0xf6, 0xec, 0x97, 0x7f, 0xeb, 0xa3, 0xf6, 0x8a, 0x0e, 0x55, 0x7d, 0x62,
+ 0x25, 0xa2, 0x4a, 0x46, 0x0b, 0xb3, 0x1a, 0x70, 0xb0, 0x3e, 0x37, 0xab, 0x72,
+ 0x89, 0xd7, 0xfb, 0x92, 0xc4, 0x21,
+ ],
+ [
+ 0x3f, 0x96, 0x8a, 0x68, 0x04, 0x88, 0xc7, 0xcb, 0x61, 0xb6, 0xa1, 0x95, 0x88,
+ 0x42, 0xe4, 0xcf, 0x63, 0x81, 0xc2, 0xba, 0xcc, 0xb5, 0x4d, 0x75, 0xd0, 0x98,
+ 0x9d, 0x14, 0x00, 0x91, 0x1d, 0xd5, 0xbb, 0x92, 0x5d, 0x07, 0x26, 0x86, 0x46,
+ 0x92, 0x07, 0x2b, 0x60, 0xdf, 0x32, 0x74, 0xd3, 0x4d,
+ ],
+ [
+ 0x0a, 0x40, 0x1a, 0xcc, 0x66, 0xfa, 0x0e, 0x2c, 0xde, 0xc5, 0xf4, 0xbc, 0xc3,
+ 0x29, 0x3a, 0x7a, 0xbb, 0x66, 0xb2, 0x02, 0x6c, 0xfd, 0x8e, 0xa2, 0xd6, 0x05,
+ 0x05, 0x38, 0x6e, 0x01, 0xc1, 0x40, 0x91, 0x04, 0x5d, 0x72, 0xe0, 0x10, 0x0b,
+ 0xaf, 0xc1, 0x2b, 0x19, 0xf1, 0xd9, 0xf8, 0x2c, 0x5b, 0x5a, 0x82, 0x07, 0xb4,
+ 0xa6, 0xa8, 0x1f, 0xf2, 0x4e, 0xf0, 0xe2, 0xfd, 0xeb, 0x63, 0xd7, 0x4d,
+ ]
+ ),
+ test_case!(
+ [
+ 0xd1, 0x1a, 0x65, 0xad, 0xe6, 0x8d, 0x31, 0x48, 0x3e, 0x7f, 0x6d, 0x8d, 0x87,
+ 0x35, 0x49, 0x0b, 0xb1, 0x0a, 0x4e, 0x39, 0x76, 0xdd, 0x7b, 0xe6, 0xf5, 0xb2,
+ 0xe7, 0x9a, 0x0e, 0x51, 0x77, 0xcc, 0xd5, 0x5c, 0x14, 0x83, 0x43, 0x49, 0x8a,
+ 0x06, 0xe4, 0x0d, 0xb1, 0xd0, 0x7e, 0x7b, 0x2e, 0x3b, 0x88, 0x90, 0x82, 0x4a,
+ 0x75, 0xad, 0xf3, 0x3d, 0x66, 0xb2, 0x11, 0xaa, 0x65, 0x24, 0xa0, 0x6e, 0x5c,
+ 0x84, 0x86, 0xd3, 0xd6, 0x46, 0xa1, 0x25, 0x56, 0xbf, 0x3e, 0x56, 0x7e, 0x09,
+ ],
+ [
+ 0xab, 0x59, 0xc9, 0x55, 0xe8, 0x24, 0x7c, 0x14, 0x73, 0xc3, 0xdb, 0x41, 0x5f,
+ 0x3f, 0x39, 0x08, 0x9f, 0x3f, 0x41, 0x1f,
+ ],
+ [
+ 0x3e, 0x72, 0xb2, 0x1b, 0x4e, 0x57, 0x95, 0x32, 0x91, 0x84, 0x0d, 0x67, 0xca,
+ 0xec, 0x66, 0xa2, 0x8b, 0x2a, 0x10, 0x88, 0x1b, 0xf0, 0x7d, 0x8d, 0xb0, 0xbd,
+ 0x80, 0xfc, 0x87, 0x55, 0xde, 0x94,
+ ],
+ [
+ 0x64, 0x6d, 0xc1, 0x8a, 0xf3, 0x64, 0x3a, 0x6a, 0x72, 0xd4, 0xfc, 0x2f, 0x09,
+ 0x56, 0x46, 0xdd, 0x01, 0xf4, 0xff, 0xd5, 0xda, 0xcc, 0x4b, 0x61, 0xbc, 0xd7,
+ 0xd1, 0x99, 0x18, 0x18, 0x4b, 0xde, 0x4a, 0xba, 0x46, 0x57, 0x6c, 0xae, 0x47,
+ 0xf8, 0x37, 0xe4, 0x0b, 0x91, 0x84, 0x06, 0x63, 0xba,
+ ],
+ [
+ 0x5f, 0x1f, 0x57, 0x75, 0xd4, 0x90, 0x73, 0x4b, 0x3b, 0xe3, 0x10, 0x17, 0x11,
+ 0x5f, 0x19, 0xab, 0xb7, 0xbb, 0xe7, 0x31, 0x1b, 0x87, 0x68, 0x57, 0xa2, 0x35,
+ 0x22, 0x30, 0x4b, 0xb4, 0x1e, 0x1d, 0x5b, 0x0d, 0x7e, 0x3c, 0xe2, 0x07, 0xb3,
+ 0x34, 0xfb, 0x10, 0x1c, 0x35, 0x41, 0xd9, 0xb6, 0xb9, 0x09, 0x44, 0x8c, 0xc5,
+ 0xb6, 0xc6, 0x1b, 0xbc, 0xc6, 0x5b, 0xba, 0x0d, 0xcb, 0x2a, 0x93, 0x20,
+ ]
+ ),
+ test_case!(
+ [
+ 0x9a, 0xe8, 0xad, 0x90, 0x0f, 0x8b, 0x6d, 0x6b, 0x02, 0x6e, 0xba, 0xbb, 0x8e,
+ 0x70, 0xb0, 0xf9, 0x02, 0xc6, 0x2c, 0xbb, 0x5d, 0x64, 0x5f, 0xf5, 0x80, 0x3e,
+ 0x47, 0x03, 0x86, 0x56, 0xf1, 0xb7, 0x6d, 0x19, 0x63, 0x61, 0xa8, 0x6d, 0x1b,
+ 0x92, 0x6a, 0x37, 0x23, 0x37, 0x46, 0x95, 0x5a, 0x07, 0xd3, 0x9a, 0xea, 0xb6,
+ 0xf2, 0x7e, 0xfa, 0x83, 0x85, 0xce, 0x02, 0xc5, 0x68, 0xa6, 0x7a, 0x8d, 0x8f,
+ 0x6e, 0xad, 0x65, 0xfb, 0x4a, 0x8d, 0xb0, 0xfa, 0x2f, 0xa6, 0x2b, 0x11, 0x0a,
+ 0xc2,
+ ],
+ [
+ 0xea, 0x99, 0x45, 0x31, 0x10, 0x5b, 0x52, 0x8f, 0x96, 0x0d, 0x57, 0x60, 0xe8,
+ 0x91, 0xb8, 0x4a, 0xcd, 0x4b, 0x0c, 0xbb,
+ ],
+ [
+ 0x62, 0x8f, 0x92, 0x62, 0x6d, 0x33, 0x04, 0x5d, 0xcc, 0x57, 0x4b, 0x45, 0xe9,
+ 0x6b, 0xc1, 0x5f, 0x06, 0x02, 0x63, 0x1f, 0x82, 0x8d, 0x05, 0xe5, 0xb1, 0x5d,
+ 0x80, 0xca, 0x01, 0xcf, 0xb1, 0x6e,
+ ],
+ [
+ 0x2f, 0x59, 0x79, 0xb7, 0x5d, 0x33, 0xdb, 0xbe, 0x68, 0xa3, 0x21, 0x1a, 0xc3,
+ 0xc2, 0x59, 0xfa, 0x2d, 0xef, 0x5e, 0xb7, 0xd8, 0x79, 0x10, 0x65, 0x75, 0x2e,
+ 0xa0, 0x4e, 0x07, 0x72, 0x18, 0xd1, 0xcf, 0x5c, 0x8f, 0x05, 0x46, 0x88, 0xd5,
+ 0x01, 0x1d, 0xc2, 0xcc, 0x20, 0x8f, 0xae, 0xbc, 0x7b,
+ ],
+ [
+ 0xec, 0xd5, 0x82, 0x7b, 0x54, 0xe1, 0x7e, 0x1e, 0x57, 0xb4, 0x8f, 0xda, 0x3d,
+ 0xf5, 0x93, 0x19, 0x26, 0x90, 0x46, 0x0d, 0x0a, 0x1f, 0x88, 0xb6, 0x1c, 0x10,
+ 0x00, 0xda, 0x92, 0xb7, 0x25, 0x9f, 0xb2, 0x0c, 0x24, 0x1d, 0x20, 0x40, 0xa4,
+ 0xd2, 0x2c, 0x2f, 0xde, 0xcc, 0xf7, 0x96, 0xeb, 0x4c, 0xa9, 0xb4, 0x0f, 0x0d,
+ 0x85, 0x4c, 0x0e, 0x85, 0x40, 0xa8, 0xe7, 0x97, 0x4e, 0x25, 0x1b, 0x51,
+ ]
+ ),
+ test_case!(
+ [
+ 0x62, 0xb9, 0x4b, 0xb4, 0xad, 0x2a, 0x5e, 0xfd, 0x4c, 0x26, 0x67, 0x36, 0x65,
+ 0xaf, 0xb6, 0xe6, 0x6d, 0x57, 0x83, 0x97, 0xcd, 0x18, 0x72, 0x63, 0x69, 0x8c,
+ 0x54, 0x1c, 0x35, 0xca, 0x7c, 0x61, 0xcf, 0x02, 0x8b, 0x45, 0x60, 0x18, 0xa1,
+ 0x22, 0xf9, 0xda, 0xb6, 0xde, 0xe2, 0x76, 0x98, 0x2a, 0x32, 0x78, 0x12, 0x3d,
+ 0xc1, 0xc0, 0x17, 0x84, 0xc1, 0x38, 0x88, 0x62, 0xdb, 0x91, 0x87, 0x9a, 0x38,
+ 0xbb, 0x64, 0x1c, 0xa2, 0x71, 0x46, 0x88, 0x58, 0xab, 0x88, 0x1d, 0x2d, 0xb6,
+ 0x2b, 0x17,
+ ],
+ [
+ 0xdc, 0x05, 0x68, 0x3e, 0x45, 0x94, 0x7c, 0x42, 0xac, 0x44, 0x29, 0xdf, 0x8d,
+ 0xfa, 0xf3, 0xfc, 0xb7, 0x77, 0xcd, 0x7d,
+ ],
+ [
+ 0x39, 0x14, 0xbf, 0xb1, 0x38, 0x82, 0xcd, 0x16, 0x8a, 0x27, 0x9c, 0x83, 0x7f,
+ 0x5f, 0x97, 0x1a, 0xcb, 0x79, 0x20, 0x9e, 0xb4, 0x63, 0xd0, 0x66, 0x39, 0x13,
+ 0x60, 0x2f, 0x38, 0xe4, 0x69, 0x5e,
+ ],
+ [
+ 0xa6, 0x52, 0xa9, 0x0f, 0xf4, 0x02, 0x27, 0x62, 0x44, 0xde, 0x4e, 0x3d, 0x87,
+ 0xb8, 0x36, 0x19, 0x23, 0xde, 0xa0, 0xd6, 0x92, 0xaf, 0x8d, 0x90, 0x92, 0x92,
+ 0x5a, 0xbb, 0x4b, 0x5f, 0x87, 0xad, 0xe7, 0xe2, 0xc0, 0x8f, 0xe8, 0x2c, 0x64,
+ 0xf9, 0xc2, 0xa9, 0x7f, 0x1b, 0xe8, 0x54, 0x4e, 0x5d,
+ ],
+ [
+ 0xa8, 0x5a, 0xbb, 0xb4, 0xdb, 0x9a, 0x79, 0xb7, 0xb0, 0x7a, 0x78, 0x01, 0x00,
+ 0x31, 0x4b, 0x25, 0xb0, 0x5b, 0xe5, 0x3f, 0x48, 0xee, 0x4f, 0xf6, 0x82, 0x00,
+ 0x82, 0x9e, 0xe5, 0x48, 0x95, 0x40, 0x91, 0x70, 0x62, 0xf6, 0x73, 0x1b, 0xe4,
+ 0x26, 0xdb, 0x94, 0x36, 0x90, 0xa9, 0x17, 0xa9, 0x6d, 0x7b, 0x87, 0x8c, 0xc9,
+ 0x94, 0xf7, 0xbb, 0x00, 0xa8, 0x93, 0x8b, 0x0e, 0x2f, 0x56, 0x93, 0x71,
+ ]
+ ),
+ test_case!(
+ [
+ 0xba, 0x3a, 0x98, 0xa7, 0x04, 0xf5, 0xa6, 0x96, 0xc0, 0x97, 0x86, 0xa6, 0x5f,
+ 0xfe, 0xdb, 0x2b, 0x80, 0x3f, 0xad, 0x60, 0x99, 0x0e, 0x39, 0x21, 0x4f, 0xfd,
+ 0x04, 0x72, 0x40, 0x4d, 0xca, 0x57, 0xd0, 0x89, 0x9e, 0x12, 0x74, 0xae, 0x67,
+ 0xb5, 0x98, 0x0e, 0xe0, 0xcf, 0x37, 0x88, 0xb7, 0x59, 0x42, 0xe0, 0xe7, 0x12,
+ 0x4b, 0x91, 0xb4, 0x52, 0x08, 0x98, 0x90, 0xc8, 0x44, 0x4b, 0x48, 0x5d, 0x84,
+ 0x2e, 0x40, 0x07, 0xf3, 0xfc, 0xc4, 0x29, 0x57, 0x86, 0x57, 0x84, 0x35, 0x7f,
+ 0xda, 0x7d, 0xaf,
+ ],
+ [
+ 0xc0, 0x28, 0x81, 0x01, 0xb4, 0x74, 0x33, 0x1c, 0x6f, 0xbf, 0xcf, 0xa9, 0x75,
+ 0xe3, 0x3b, 0x7a, 0x2e, 0x75, 0x98, 0x8b,
+ ],
+ [
+ 0x4f, 0x37, 0x3a, 0x1a, 0x7c, 0xaa, 0x1a, 0x06, 0xf4, 0xed, 0x46, 0x45, 0x82,
+ 0x05, 0x09, 0x9b, 0xf1, 0x6b, 0xb2, 0xb2, 0x7f, 0x86, 0xe2, 0x43, 0xab, 0xc3,
+ 0x33, 0x10, 0x33, 0x34, 0x16, 0x1d,
+ ],
+ [
+ 0x60, 0xa7, 0x1d, 0x42, 0x8c, 0x1a, 0xd4, 0x0b, 0x3f, 0xec, 0x68, 0xb7, 0x0f,
+ 0xf9, 0x06, 0xf7, 0x82, 0x02, 0xa1, 0xcc, 0x5d, 0xda, 0x0d, 0x9f, 0x46, 0xa9,
+ 0x43, 0x74, 0xd2, 0x4e, 0xe0, 0x38, 0xb4, 0xb0, 0x0a, 0x87, 0xd0, 0x6b, 0x28,
+ 0x53, 0x4f, 0x21, 0xce, 0x3f, 0xcb, 0x26, 0x7b, 0xbf,
+ ],
+ [
+ 0x22, 0x9d, 0x9b, 0xa0, 0x91, 0xda, 0x8e, 0x02, 0xcc, 0xf6, 0xc0, 0x69, 0xd2,
+ 0x49, 0xba, 0x40, 0xf7, 0xd8, 0x1e, 0xe7, 0xee, 0xed, 0xdc, 0x35, 0x84, 0x5c,
+ 0x1e, 0xec, 0x00, 0x22, 0x78, 0x64, 0xbc, 0xc3, 0xfd, 0x52, 0x7a, 0xf8, 0x81,
+ 0x63, 0x30, 0x1f, 0xa9, 0x45, 0xbe, 0x29, 0x06, 0xee, 0xce, 0xab, 0x8b, 0x43,
+ 0x68, 0x51, 0x6a, 0xa3, 0x94, 0xa6, 0x8d, 0x82, 0xb2, 0x27, 0x7d, 0xc1,
+ ]
+ ),
+ test_case!(
+ [
+ 0xb2, 0xd5, 0x27, 0x3a, 0x74, 0xb8, 0xf7, 0xf6, 0x53, 0xc8, 0x27, 0xa2, 0x3e,
+ 0x1e, 0xd1, 0x29, 0xdd, 0x0a, 0x13, 0x41, 0xb4, 0xba, 0x1f, 0x7a, 0xbc, 0x74,
+ 0x1f, 0x07, 0x23, 0x79, 0xc3, 0x68, 0x75, 0x6c, 0x17, 0xb7, 0x20, 0x58, 0x07,
+ 0x86, 0x7e, 0x17, 0x79, 0xc3, 0x0c, 0xe0, 0xaf, 0xa1, 0x7b, 0xe6, 0x20, 0xa9,
+ 0xa8, 0x15, 0x10, 0xc9, 0x9a, 0xad, 0x61, 0x09, 0xf0, 0xeb, 0xe8, 0x38, 0x33,
+ 0x0e, 0x62, 0x53, 0x46, 0xbb, 0x30, 0xbb, 0x9e, 0x63, 0x8e, 0x0a, 0x4c, 0x1d,
+ 0xb1, 0x4f, 0xf8, 0xf1,
+ ],
+ [
+ 0x9e, 0x3f, 0xe2, 0x4b, 0x16, 0x89, 0x11, 0x74, 0x8b, 0x0e, 0x10, 0x28, 0x02,
+ 0xb2, 0x09, 0xb9, 0x7f, 0xc2, 0x1e, 0x40,
+ ],
+ [
+ 0xcc, 0xaa, 0x31, 0xd9, 0x53, 0x54, 0xd4, 0x94, 0x68, 0x36, 0x23, 0xa1, 0x78,
+ 0x27, 0x27, 0x3e, 0x61, 0xf0, 0x02, 0xd0, 0xb8, 0xa1, 0x24, 0x78, 0x3f, 0xcd,
+ 0xbc, 0x0e, 0x6e, 0x84, 0xbf, 0x01,
+ ],
+ [
+ 0xd6, 0x79, 0x53, 0x4b, 0xbf, 0x5e, 0x72, 0x81, 0x1c, 0xd9, 0xb9, 0x84, 0xb4,
+ 0x00, 0xa2, 0x50, 0xf7, 0x23, 0x8c, 0x88, 0x09, 0x61, 0x55, 0x44, 0xfb, 0xbf,
+ 0x93, 0x1b, 0x8a, 0xb7, 0x2f, 0x10, 0x70, 0x9d, 0x98, 0xf8, 0x59, 0x39, 0xd0,
+ 0xfc, 0x95, 0x88, 0x3d, 0x23, 0x5a, 0x93, 0xbd, 0x84,
+ ],
+ [
+ 0x45, 0x21, 0x35, 0x2f, 0x3b, 0x27, 0xe2, 0x95, 0x45, 0x77, 0x1c, 0x08, 0x8c,
+ 0x77, 0xf6, 0x6d, 0xe7, 0xbc, 0x2d, 0x2b, 0xd7, 0x71, 0xe0, 0x11, 0x60, 0x29,
+ 0x9b, 0x1d, 0x18, 0x34, 0xaa, 0xf8, 0xb3, 0xf2, 0xe5, 0xb5, 0xfd, 0x80, 0xb8,
+ 0x7f, 0x7c, 0x3d, 0xc5, 0xb5, 0xb0, 0x2a, 0x18, 0xdf, 0x63, 0xec, 0x94, 0x81,
+ 0x91, 0x5f, 0x68, 0x64, 0xe2, 0x47, 0x55, 0x80, 0x73, 0xbd, 0xbc, 0x7c,
+ ]
+ ),
+ test_case!(
+ [
+ 0x3a, 0x1a, 0xa4, 0xd3, 0xb2, 0x5b, 0x57, 0x88, 0xc6, 0x86, 0xdf, 0x7f, 0x60,
+ 0x4b, 0x0f, 0xa5, 0x46, 0x1e, 0x61, 0x28, 0xa8, 0x7a, 0x09, 0xc7, 0x47, 0x6d,
+ 0xa4, 0xb7, 0x30, 0xa9, 0xf7, 0x0e, 0xbf, 0x58, 0xc7, 0x8c, 0xfa, 0x62, 0x69,
+ 0xac, 0x9d, 0x2c, 0xfe, 0xd4, 0x45, 0x70, 0x55, 0x25, 0xee, 0x1e, 0x12, 0x28,
+ 0x72, 0x96, 0x65, 0xc7, 0x7c, 0xbb, 0xc7, 0x49, 0x00, 0x79, 0x53, 0xba, 0x2f,
+ 0x6e, 0xbe, 0xec, 0x8a, 0xf0, 0xe8, 0xff, 0xc1, 0x0d, 0x31, 0xfc, 0xf2, 0x04,
+ 0xe2, 0x54, 0x8b, 0x44, 0x8f,
+ ],
+ [
+ 0xa6, 0x28, 0x1c, 0xd5, 0x57, 0x89, 0x30, 0x48, 0x01, 0xff, 0x6e, 0x84, 0x45,
+ 0x80, 0x19, 0x28, 0x4b, 0xec, 0xc9, 0xda,
+ ],
+ [
+ 0x36, 0x27, 0xa9, 0x7f, 0x26, 0x85, 0xcf, 0x03, 0x0f, 0xd9, 0x75, 0xa7, 0x71,
+ 0xd7, 0xd6, 0xcb, 0xf9, 0x7d, 0x86, 0xf9, 0x6f, 0xcc, 0x97, 0xa8, 0xed, 0x43,
+ 0x22, 0xe7, 0x2f, 0xaf, 0x39, 0x84,
+ ],
+ [
+ 0x61, 0xec, 0x2a, 0x18, 0x52, 0xbe, 0xc4, 0x7d, 0x84, 0xd7, 0xd9, 0xdc, 0xb3,
+ 0xe2, 0x5e, 0x94, 0xf2, 0x62, 0xe0, 0x42, 0xf2, 0xea, 0x65, 0x97, 0x85, 0x82,
+ 0x77, 0xbe, 0xea, 0x13, 0x52, 0x8d, 0x30, 0xa3, 0xda, 0x80, 0x8d, 0x62, 0x2c,
+ 0x56, 0xf7, 0x57, 0x8c, 0xf2, 0x93, 0xc3, 0x2b, 0xf2,
+ ],
+ [
+ 0x63, 0xde, 0xd0, 0x79, 0x47, 0x76, 0xb7, 0x63, 0xb9, 0x48, 0xfd, 0x29, 0x5c,
+ 0xc0, 0x70, 0xf3, 0xb0, 0x89, 0x13, 0x45, 0xea, 0xb9, 0xec, 0x80, 0xd3, 0xdd,
+ 0x79, 0xad, 0x22, 0x22, 0xa4, 0x56, 0xb0, 0xf2, 0xaa, 0x80, 0x22, 0xe2, 0x23,
+ 0xc3, 0xcb, 0x25, 0x84, 0x8d, 0xbe, 0x92, 0xd9, 0x8d, 0x45, 0xb4, 0xa2, 0xc1,
+ 0xa0, 0x7e, 0x98, 0xfa, 0x81, 0x94, 0x46, 0x97, 0xf9, 0x4a, 0xd7, 0xf6,
+ ]
+ ),
+ test_case!(
+ [
+ 0x5e, 0x80, 0xab, 0x35, 0x62, 0x28, 0xe1, 0x81, 0x50, 0xe8, 0xd2, 0x3f, 0x1e,
+ 0x58, 0x74, 0xb8, 0x41, 0x55, 0x17, 0x4d, 0x13, 0xba, 0xff, 0x53, 0x07, 0xf3,
+ 0x52, 0x42, 0x19, 0x8d, 0x34, 0x56, 0x08, 0x5a, 0x34, 0xc6, 0x7f, 0x5c, 0x60,
+ 0xd3, 0xed, 0x95, 0x68, 0xcc, 0x69, 0xa4, 0xca, 0x4b, 0x7a, 0xe6, 0x28, 0x9b,
+ 0x87, 0xb1, 0xa5, 0x39, 0x49, 0x3f, 0x50, 0xb6, 0x26, 0x31, 0x5e, 0xa7, 0xf3,
+ 0x43, 0x6f, 0xa0, 0xee, 0xc7, 0xdf, 0x0a, 0xcc, 0xae, 0xd6, 0xa2, 0x59, 0x01,
+ 0x5f, 0xcf, 0x71, 0x49, 0x97, 0xc5,
+ ],
+ [
+ 0x3d, 0x37, 0x10, 0x21, 0xe7, 0x3f, 0x1f, 0xd5, 0xca, 0xa0, 0x41, 0xa3, 0xb4,
+ 0xd4, 0xa5, 0x64, 0xc6, 0x4c, 0x04, 0x92,
+ ],
+ [
+ 0x7e, 0xca, 0x32, 0x96, 0x12, 0x8b, 0x47, 0xb5, 0xf3, 0xe4, 0xc2, 0xee, 0x68,
+ 0xf3, 0x97, 0x4b, 0x5c, 0xbb, 0xf6, 0xd3, 0x10, 0x45, 0x6e, 0xce, 0x50, 0xf6,
+ 0xb9, 0x85, 0x17, 0xdd, 0x6b, 0x17,
+ ],
+ [
+ 0xd0, 0x3f, 0x40, 0x7e, 0xa2, 0x69, 0x09, 0xc8, 0x33, 0x11, 0xb7, 0x07, 0x95,
+ 0x0d, 0xa9, 0xad, 0xf7, 0x1f, 0xdc, 0xdb, 0x07, 0x56, 0x96, 0x33, 0xb8, 0xfd,
+ 0x74, 0xa6, 0x5c, 0x39, 0x71, 0x46, 0xe9, 0xd8, 0xd9, 0x10, 0x68, 0x0d, 0x33,
+ 0x35, 0x38, 0xac, 0xca, 0x4b, 0x68, 0x00, 0xc7, 0xf5,
+ ],
+ [
+ 0x89, 0x4f, 0xfa, 0xd9, 0xb5, 0x47, 0xd7, 0xae, 0x7a, 0x97, 0xfb, 0x82, 0xf6,
+ 0xad, 0xde, 0xbc, 0xf9, 0xf9, 0xd9, 0x24, 0x61, 0x04, 0x55, 0xf6, 0x8d, 0xf1,
+ 0x79, 0x31, 0xf7, 0xb8, 0x9c, 0x2e, 0xcd, 0x88, 0x98, 0x6c, 0xfa, 0xdc, 0x37,
+ 0xfe, 0xc8, 0xc6, 0xec, 0x4e, 0x16, 0xda, 0x5f, 0x8b, 0x7f, 0xda, 0x0a, 0x11,
+ 0xe9, 0x92, 0xde, 0x63, 0x51, 0xc0, 0x6e, 0xea, 0xb8, 0xcc, 0x6b, 0x34,
+ ]
+ ),
+ test_case!(
+ [
+ 0xfa, 0xf5, 0x61, 0x5e, 0x3d, 0x18, 0x78, 0x43, 0xdf, 0xed, 0x6b, 0xf1, 0x08,
+ 0xd8, 0x69, 0xe8, 0x22, 0x1f, 0x48, 0xce, 0x8f, 0x76, 0x54, 0xff, 0xc3, 0xbf,
+ 0x42, 0x31, 0xeb, 0x65, 0x8b, 0x4d, 0x15, 0x4a, 0x6e, 0x38, 0xf6, 0xaa, 0xac,
+ 0xbb, 0xe2, 0xbd, 0x06, 0xf6, 0xb3, 0x22, 0x2c, 0xca, 0x58, 0x01, 0x34, 0xd3,
+ 0x0c, 0xa6, 0xd0, 0xed, 0x2b, 0x28, 0x57, 0xf8, 0xb5, 0xeb, 0x9d, 0xf1, 0xa8,
+ 0xf4, 0x3e, 0x0d, 0x67, 0x05, 0xbb, 0xe2, 0x4a, 0x69, 0x7b, 0xa7, 0x9f, 0x0f,
+ 0x31, 0xa8, 0x49, 0x4b, 0x9d, 0x54, 0xd6,
+ ],
+ [
+ 0xfe, 0xa8, 0xd3, 0x53, 0x2f, 0x48, 0x06, 0xaa, 0xd4, 0x94, 0xce, 0xa0, 0xcc,
+ 0xc9, 0x5b, 0x5e, 0x99, 0xa5, 0x1f, 0xd9,
+ ],
+ [
+ 0x57, 0x26, 0x38, 0x9b, 0x03, 0x68, 0xa9, 0x28, 0xcc, 0x16, 0x65, 0xd7, 0x56,
+ 0x18, 0xb9, 0x33, 0x74, 0x86, 0x97, 0xfc, 0x7a, 0x0a, 0x36, 0x4b, 0xda, 0xd0,
+ 0x24, 0x66, 0xe9, 0x5c, 0x0a, 0x3d,
+ ],
+ [
+ 0x25, 0x31, 0x26, 0x5d, 0xbb, 0x78, 0x2a, 0xa7, 0x1a, 0x1e, 0x8b, 0x24, 0xdd,
+ 0xbd, 0xf0, 0xe8, 0xcb, 0x0c, 0x84, 0x35, 0x66, 0x03, 0x10, 0x42, 0x94, 0x49,
+ 0xf7, 0x16, 0x37, 0x66, 0x9e, 0xdc, 0x35, 0xb9, 0x69, 0xec, 0x0b, 0x42, 0x66,
+ 0x79, 0x6e, 0xd7, 0xfa, 0x4f, 0x37, 0xc3, 0x33, 0x25,
+ ],
+ [
+ 0xd5, 0x6b, 0xe6, 0x65, 0x61, 0xc2, 0x08, 0xe0, 0x85, 0xdc, 0x81, 0xe1, 0x41,
+ 0x54, 0xbb, 0x0a, 0xcc, 0xfb, 0xf8, 0x3e, 0x2e, 0xdf, 0x31, 0xc4, 0x68, 0x3d,
+ 0x03, 0x87, 0x04, 0x03, 0x5e, 0xc8, 0x3a, 0xc2, 0x5a, 0xe0, 0x2c, 0x62, 0x90,
+ 0x33, 0xc7, 0xd1, 0x64, 0xe1, 0xe9, 0xff, 0x20, 0x43, 0x46, 0x60, 0x1a, 0x8d,
+ 0x70, 0x00, 0x60, 0xdd, 0x1e, 0x84, 0x16, 0x5b, 0x53, 0x93, 0x03, 0xc7,
+ ]
+ ),
+ test_case!(
+ [
+ 0x1b, 0x27, 0xa7, 0x1d, 0x7f, 0x5a, 0x9e, 0xb7, 0x49, 0xe9, 0x37, 0x2d, 0x6c,
+ 0xc7, 0x21, 0xb9, 0xd7, 0x26, 0x9a, 0xa2, 0x3a, 0x23, 0x6c, 0x70, 0xc6, 0x09,
+ 0xd0, 0x93, 0xfd, 0xbd, 0x30, 0x74, 0x41, 0xcb, 0x6f, 0x56, 0x70, 0xc7, 0x43,
+ 0xcb, 0x2d, 0x6b, 0xd5, 0xfe, 0x6e, 0xd5, 0xa2, 0x0c, 0x65, 0xaf, 0xab, 0x3d,
+ 0x81, 0x57, 0x94, 0xc2, 0x21, 0xf2, 0x59, 0x12, 0xac, 0x1d, 0xc2, 0x8f, 0x1f,
+ 0xf7, 0xb4, 0x6a, 0x98, 0xb0, 0x15, 0x76, 0x07, 0xc7, 0x3e, 0xd3, 0x61, 0x74,
+ 0x20, 0x21, 0x07, 0xc3, 0x65, 0x66, 0x2c, 0x69,
+ ],
+ [
+ 0xfe, 0x5d, 0x0a, 0x51, 0xb5, 0x15, 0x97, 0x07, 0x30, 0xe7, 0x9b, 0x0c, 0xff,
+ 0xb7, 0x5c, 0x4b, 0xee, 0x10, 0x0a, 0x0d,
+ ],
+ [
+ 0x71, 0x86, 0xe6, 0xcb, 0xaa, 0xe2, 0x86, 0x47, 0x84, 0x50, 0x44, 0x39, 0xd1,
+ 0x37, 0xf5, 0xf8, 0xbf, 0x29, 0x9a, 0xd6, 0x02, 0x80, 0x7c, 0xa6, 0xdc, 0x98,
+ 0xc6, 0x91, 0x19, 0xaf, 0x88, 0x9d,
+ ],
+ [
+ 0x45, 0xb1, 0x82, 0x34, 0x71, 0xae, 0xa0, 0x29, 0xaa, 0x27, 0xf1, 0xc0, 0x4d,
+ 0x63, 0xab, 0xde, 0xda, 0x26, 0x97, 0x9e, 0x16, 0xa9, 0x22, 0xad, 0x23, 0x74,
+ 0x5b, 0xfc, 0xc4, 0xa8, 0xab, 0x47, 0xa5, 0x38, 0x43, 0x46, 0x57, 0x88, 0x11,
+ 0x1e, 0x3c, 0xd5, 0x96, 0xe5, 0x7e, 0x03, 0x4a, 0x34,
+ ],
+ [
+ 0x0c, 0x30, 0xb8, 0xa9, 0x6a, 0xec, 0x86, 0x0b, 0xaa, 0x72, 0x0e, 0xc0, 0xd0,
+ 0xcb, 0x96, 0xdc, 0xbb, 0xab, 0x0e, 0x0d, 0xb4, 0xb1, 0x5b, 0x60, 0xc8, 0x06,
+ 0xd7, 0x62, 0x2d, 0xa7, 0x30, 0x3a, 0x82, 0x84, 0x1f, 0x4f, 0x5b, 0x9a, 0xcd,
+ 0x12, 0x26, 0x29, 0x8a, 0x13, 0x96, 0x9e, 0xad, 0x77, 0x48, 0xe5, 0x59, 0x37,
+ 0x7d, 0x90, 0x17, 0x10, 0xc1, 0x40, 0x48, 0xab, 0x92, 0x2c, 0x30, 0x53,
+ ]
+ ),
+ test_case!(
+ [
+ 0xa8, 0x72, 0x57, 0xc0, 0xff, 0x86, 0xb7, 0x84, 0x6a, 0xc3, 0xff, 0x7f, 0x90,
+ 0x02, 0xba, 0x53, 0xc0, 0xb7, 0x50, 0x48, 0x4d, 0x20, 0xa6, 0xab, 0x6d, 0x6c,
+ 0x1a, 0xbf, 0xac, 0x5f, 0x20, 0x16, 0x90, 0x61, 0x7b, 0xfb, 0x2e, 0x44, 0xbb,
+ 0x60, 0xe9, 0x00, 0x5f, 0xd1, 0xb5, 0xfc, 0xe0, 0x75, 0x69, 0x61, 0x9b, 0xca,
+ 0x7e, 0xfc, 0x54, 0x43, 0x81, 0x66, 0xfa, 0xbf, 0xeb, 0xbd, 0xac, 0x04, 0x16,
+ 0xe1, 0x2e, 0x89, 0x7b, 0x4f, 0x3f, 0xef, 0x36, 0xac, 0x30, 0x0c, 0x50, 0xff,
+ 0x2a, 0x99, 0xfc, 0x5c, 0xa7, 0x39, 0x16, 0x16, 0xc7,
+ ],
+ [
+ 0x52, 0xe3, 0x90, 0x87, 0x5c, 0xc0, 0x19, 0xd0, 0xaa, 0x47, 0x3e, 0x86, 0x63,
+ 0xf8, 0xfe, 0xfb, 0xbb, 0x31, 0x90, 0xd2,
+ ],
+ [
+ 0x7f, 0xec, 0x36, 0xac, 0xc9, 0x0c, 0xfa, 0x26, 0xd3, 0x4c, 0x3d, 0x3d, 0x55,
+ 0x67, 0xd2, 0x88, 0x54, 0x81, 0x07, 0xb8, 0x36, 0xd7, 0x35, 0x87, 0xe2, 0xca,
+ 0x7c, 0x0d, 0xaa, 0xe4, 0x5a, 0x5a,
+ ],
+ [
+ 0x37, 0x0c, 0x87, 0xe5, 0x59, 0x7c, 0x71, 0x5d, 0x47, 0x22, 0x03, 0x76, 0xd2,
+ 0x86, 0xca, 0xf6, 0x8f, 0xd8, 0x19, 0x5a, 0xd9, 0x0e, 0x9a, 0xbb, 0x5b, 0xac,
+ 0x9a, 0xc3, 0xa4, 0xf6, 0xea, 0xe2, 0xe2, 0x91, 0x23, 0x40, 0x6f, 0xbf, 0xcd,
+ 0x5d, 0x2d, 0x02, 0x32, 0xfa, 0x85, 0xd8, 0x83, 0x89,
+ ],
+ [
+ 0x80, 0xeb, 0x72, 0xd7, 0x19, 0xda, 0xd7, 0x9b, 0x94, 0xeb, 0x27, 0x1d, 0x27,
+ 0xea, 0x34, 0x3d, 0xd4, 0x06, 0x44, 0x2e, 0x1c, 0x79, 0x2b, 0x4b, 0x99, 0x40,
+ 0x73, 0x5c, 0xbe, 0x95, 0x92, 0x35, 0xb4, 0xa4, 0xea, 0xbf, 0xf4, 0xc6, 0x91,
+ 0x2e, 0xf1, 0xc0, 0x90, 0x7a, 0xb4, 0x5a, 0x35, 0xaf, 0x59, 0xeb, 0xf0, 0x6b,
+ 0x09, 0xff, 0xb8, 0x81, 0xa6, 0x7f, 0x83, 0xd1, 0x93, 0xfa, 0x16, 0x31,
+ ]
+ ),
+ test_case!(
+ [
+ 0xde, 0xfe, 0xed, 0x0b, 0xf4, 0xcc, 0x79, 0x9e, 0xc4, 0x06, 0xdb, 0x1e, 0xcc,
+ 0x19, 0xde, 0xaa, 0x6f, 0xa0, 0x51, 0x2b, 0x04, 0xd9, 0x69, 0x71, 0x79, 0xa1,
+ 0x3e, 0xc7, 0x0e, 0x9b, 0xe6, 0xbb, 0xa1, 0x40, 0x39, 0x52, 0x88, 0x73, 0x55,
+ 0x99, 0xce, 0x29, 0xc2, 0xb9, 0x19, 0xb9, 0xf3, 0x0f, 0x9a, 0x4f, 0x84, 0xcd,
+ 0xd6, 0x3b, 0x77, 0x07, 0xaf, 0xaa, 0x7e, 0xa3, 0xf3, 0x73, 0x9c, 0xd3, 0x57,
+ 0x8b, 0x00, 0xbb, 0x9e, 0x56, 0x8c, 0x43, 0x7d, 0x3f, 0xee, 0x5d, 0x44, 0x5d,
+ 0x46, 0x90, 0x2c, 0x59, 0xff, 0x00, 0xe0, 0x8f, 0x05, 0x64,
+ ],
+ [
+ 0xe5, 0xeb, 0xe8, 0x67, 0xef, 0x21, 0xc3, 0xfd, 0x82, 0x15, 0xa7, 0x66, 0x08,
+ 0x89, 0xce, 0x04, 0x17, 0xad, 0xdf, 0x01,
+ ],
+ [
+ 0x7b, 0x2c, 0xf0, 0x87, 0xc6, 0x68, 0x65, 0x8f, 0x4b, 0x94, 0x64, 0xb5, 0x56,
+ 0x92, 0xbc, 0xe1, 0x8a, 0x63, 0x3b, 0x5b, 0xf5, 0x30, 0xd0, 0xb4, 0xb6, 0x14,
+ 0xef, 0x40, 0xbf, 0x3c, 0xdf, 0x1c,
+ ],
+ [
+ 0x5c, 0x43, 0xcd, 0x0e, 0x87, 0x2c, 0x9b, 0x51, 0x5f, 0x4b, 0x4a, 0x66, 0x39,
+ 0x32, 0x46, 0x71, 0xc3, 0xa3, 0x2a, 0xe0, 0xbb, 0x20, 0x4e, 0x4f, 0xe1, 0xbc,
+ 0x74, 0x08, 0xed, 0x64, 0xb4, 0xc4, 0xb3, 0x34, 0x40, 0x4e, 0x84, 0x6c, 0x3a,
+ 0x81, 0x36, 0xea, 0xcf, 0x0e, 0x7a, 0xbf, 0x90, 0x43,
+ ],
+ [
+ 0x61, 0x0d, 0x53, 0xba, 0x5a, 0x43, 0xe0, 0x47, 0xf8, 0x60, 0xed, 0x99, 0x61,
+ 0x74, 0x1d, 0x18, 0x6e, 0x06, 0x83, 0xfa, 0x2a, 0x7a, 0xc3, 0x12, 0x45, 0x28,
+ 0x38, 0x46, 0x9f, 0x2c, 0xd6, 0x9e, 0xbf, 0xc7, 0xe2, 0x77, 0xe0, 0x4a, 0x7f,
+ 0x4e, 0x59, 0x08, 0x94, 0xf3, 0x32, 0x3a, 0xaf, 0xe5, 0x41, 0x49, 0x23, 0x2b,
+ 0xc4, 0x8f, 0x0d, 0x8c, 0xd3, 0x74, 0xcc, 0x79, 0x2f, 0xd1, 0x68, 0xb7,
+ ]
+ ),
+ test_case!(
+ [
+ 0x93, 0x6a, 0xfa, 0xf9, 0x63, 0xb3, 0x57, 0x0d, 0x66, 0x5e, 0xb3, 0xe2, 0xf4,
+ 0x43, 0xbd, 0x8f, 0xbe, 0x7e, 0xa7, 0x65, 0x20, 0x03, 0xbe, 0x67, 0x0d, 0x10,
+ 0xdc, 0x48, 0x1c, 0xf6, 0x31, 0x56, 0x8a, 0x4b, 0x96, 0x92, 0xc6, 0x15, 0xea,
+ 0xdc, 0xe8, 0xd6, 0x3f, 0x6c, 0xad, 0x05, 0x0a, 0xca, 0xd2, 0xc7, 0x34, 0xb9,
+ 0x06, 0xf4, 0x24, 0xcf, 0x2f, 0x8d, 0xbd, 0x6e, 0xe7, 0x6f, 0x40, 0xf8, 0x35,
+ 0xab, 0x75, 0x6e, 0x41, 0xe2, 0x9e, 0x33, 0x77, 0x27, 0x07, 0xf4, 0xbc, 0x75,
+ 0x9f, 0x23, 0xfc, 0xee, 0x4a, 0x40, 0x5a, 0x93, 0xbf, 0x6f, 0xb9,
+ ],
+ [
+ 0x81, 0x0f, 0x96, 0xcb, 0x7f, 0x0f, 0x0c, 0xd1, 0xb1, 0x81, 0xf6, 0x1f, 0x03,
+ 0x82, 0x62, 0x46, 0x47, 0x78, 0xad, 0x6e,
+ ],
+ [
+ 0x44, 0x84, 0x77, 0xea, 0xa7, 0x51, 0xf3, 0x6e, 0x74, 0x96, 0x2b, 0xa3, 0xca,
+ 0x11, 0xb7, 0xa6, 0xf7, 0x4d, 0xd8, 0xd4, 0x54, 0x4c, 0xfa, 0x71, 0x5f, 0x68,
+ 0x00, 0xda, 0x46, 0xa7, 0xa9, 0xf0,
+ ],
+ [
+ 0xa7, 0xe1, 0x29, 0x03, 0x28, 0x29, 0x22, 0x00, 0x21, 0x98, 0x60, 0x1b, 0xe0,
+ 0x26, 0xda, 0xbc, 0x19, 0x58, 0x5c, 0x0b, 0x1d, 0x6a, 0x82, 0xd7, 0x18, 0x44,
+ 0xa2, 0x91, 0xe4, 0x7c, 0xce, 0x6e, 0xae, 0x4c, 0x54, 0x1c, 0xdf, 0xa5, 0x0a,
+ 0x0c, 0x5f, 0xb2, 0x76, 0x02, 0x32, 0x5f, 0x8e, 0x05,
+ ],
+ [
+ 0xbf, 0x4a, 0x53, 0xea, 0x81, 0xb4, 0x3b, 0x94, 0x0b, 0xde, 0xab, 0x7c, 0x34,
+ 0x84, 0x1b, 0x8c, 0x6f, 0x7d, 0xf8, 0x34, 0x13, 0x57, 0x77, 0x51, 0x12, 0x48,
+ 0xc9, 0xc2, 0xc1, 0xb8, 0xa3, 0x8c, 0xf6, 0x2b, 0x14, 0xcc, 0x47, 0xe5, 0xa1,
+ 0xd2, 0xf9, 0xf7, 0xd9, 0x78, 0xc9, 0x38, 0x9a, 0xcc, 0xdb, 0x67, 0x25, 0xe2,
+ 0x39, 0xab, 0x8f, 0x15, 0xc4, 0xdc, 0x51, 0xbe, 0x1f, 0xa2, 0x4c, 0x9d,
+ ]
+ ),
+ test_case!(
+ [
+ 0xa5, 0x28, 0x18, 0xd8, 0x0b, 0xab, 0x0f, 0x50, 0x1e, 0x64, 0x5b, 0x32, 0x27,
+ 0x2c, 0x86, 0xc3, 0xdd, 0x73, 0x9a, 0x50, 0x9b, 0x88, 0x90, 0x37, 0xff, 0x70,
+ 0xa0, 0x8a, 0x8e, 0x96, 0x9e, 0xd6, 0x02, 0xf4, 0xfd, 0x37, 0xf9, 0x76, 0x92,
+ 0x88, 0x71, 0x30, 0x64, 0x41, 0x73, 0xe7, 0x53, 0x3e, 0x15, 0x84, 0xa9, 0xc5,
+ 0x23, 0xdb, 0x68, 0xf8, 0x14, 0xa4, 0xae, 0x02, 0xff, 0x98, 0xd3, 0x9e, 0xde,
+ 0xdc, 0x8c, 0xa3, 0x95, 0x62, 0xa8, 0xed, 0x1e, 0xad, 0x0f, 0x96, 0xcf, 0x7c,
+ 0x73, 0x29, 0x50, 0x02, 0x53, 0xb4, 0x8d, 0x06, 0xbc, 0x38, 0x20, 0x05,
+ ],
+ [
+ 0x3e, 0xec, 0x10, 0x1f, 0x47, 0x63, 0xc4, 0x3f, 0xbd, 0xaf, 0x3d, 0x41, 0xea,
+ 0x97, 0x57, 0x81, 0x6a, 0x7b, 0x20, 0xb5,
+ ],
+ [
+ 0x89, 0x6d, 0x0e, 0x73, 0x64, 0xd3, 0xeb, 0xbc, 0xa0, 0x0d, 0x11, 0x57, 0xd3,
+ 0x3f, 0x5e, 0x3e, 0x83, 0xa1, 0xd7, 0x87, 0x63, 0x39, 0x3e, 0x08, 0x37, 0x8a,
+ 0xb6, 0x8a, 0x6e, 0x6a, 0x77, 0xce,
+ ],
+ [
+ 0x0b, 0x84, 0x2b, 0xca, 0xa0, 0x9f, 0xff, 0xef, 0x99, 0x96, 0x68, 0x40, 0x78,
+ 0x1e, 0xcd, 0xc1, 0xf3, 0x27, 0x11, 0xfa, 0x66, 0x81, 0x46, 0x43, 0x42, 0x3f,
+ 0x06, 0x11, 0xa7, 0xf6, 0xf4, 0x5c, 0x9d, 0xbf, 0xc6, 0x5e, 0x0e, 0x3e, 0x1b,
+ 0x36, 0x4b, 0x03, 0xb4, 0x70, 0x7d, 0x2d, 0x0f, 0xf6,
+ ],
+ [
+ 0x95, 0x9b, 0x3d, 0x64, 0xc5, 0x32, 0x58, 0xb3, 0xda, 0x57, 0xa4, 0x8f, 0x5c,
+ 0xda, 0xae, 0x64, 0x6e, 0x98, 0xb0, 0x0b, 0x69, 0x14, 0x34, 0xed, 0xab, 0x4e,
+ 0xd6, 0x15, 0x4e, 0x99, 0x94, 0x0e, 0xcc, 0x75, 0x1c, 0xaf, 0xb0, 0x92, 0x36,
+ 0x82, 0x3b, 0x7c, 0xd2, 0xee, 0xca, 0xe3, 0x8a, 0x7d, 0xc9, 0x31, 0x67, 0x5b,
+ 0xd2, 0x92, 0xbc, 0xdd, 0xf3, 0x1b, 0x57, 0xef, 0xcd, 0xf4, 0xc7, 0xf7,
+ ]
+ ),
+ test_case!(
+ [
+ 0xbe, 0xc0, 0xc0, 0xce, 0x37, 0xb7, 0xe0, 0x04, 0x1e, 0x2e, 0xca, 0x66, 0x45,
+ 0xc6, 0x77, 0x04, 0x73, 0x4a, 0xf8, 0x58, 0x73, 0xa5, 0x56, 0x2b, 0x9a, 0x3a,
+ 0xcb, 0x39, 0xed, 0x1c, 0x66, 0xbf, 0x33, 0x5d, 0x72, 0x12, 0xb5, 0x93, 0x40,
+ 0xb9, 0xca, 0x1c, 0x08, 0x4f, 0x6e, 0x92, 0xbd, 0xdd, 0xc8, 0xcd, 0xaf, 0x50,
+ 0xe9, 0x9f, 0x73, 0x09, 0x36, 0x38, 0x71, 0xb7, 0x77, 0xa4, 0x92, 0x66, 0x86,
+ 0x08, 0x1a, 0xcc, 0xf5, 0x8d, 0xf1, 0x8c, 0xbe, 0x6b, 0x01, 0x12, 0xd8, 0x2b,
+ 0xf0, 0x1e, 0x75, 0xe2, 0xe3, 0x15, 0xb3, 0x1a, 0xfb, 0xd2, 0xe4, 0x5f, 0x2c,
+ ],
+ [
+ 0x9f, 0x36, 0xfa, 0x6a, 0x1e, 0x0e, 0xfa, 0x50, 0x64, 0xff, 0x56, 0x66, 0xe8,
+ 0xce, 0xd5, 0x59, 0x2d, 0x9d, 0xc3, 0x90,
+ ],
+ [
+ 0xf1, 0xd7, 0x2b, 0x13, 0x99, 0xe1, 0x05, 0xdc, 0x4f, 0xc3, 0xab, 0xf6, 0xa7,
+ 0x1f, 0x62, 0x38, 0x0e, 0xac, 0x31, 0xe3, 0x3b, 0x10, 0x65, 0x14, 0xbc, 0x28,
+ 0xdb, 0x03, 0x2c, 0xc6, 0x9e, 0xd5,
+ ],
+ [
+ 0xb1, 0x03, 0xf9, 0x6a, 0x68, 0x5b, 0xdb, 0x31, 0xbd, 0xf8, 0x75, 0xc5, 0x60,
+ 0x98, 0x05, 0x0a, 0xd3, 0x67, 0xc2, 0xc1, 0xd2, 0xcf, 0x89, 0x94, 0x6e, 0x27,
+ 0x78, 0xc1, 0x86, 0xf7, 0xfe, 0xb1, 0xd5, 0x5b, 0xb2, 0x19, 0x85, 0x91, 0x98,
+ 0x32, 0x05, 0xf1, 0x1a, 0x3b, 0x73, 0xef, 0x41, 0x07,
+ ],
+ [
+ 0x5d, 0x83, 0xc3, 0xc9, 0xa2, 0x00, 0xa5, 0xc9, 0x1d, 0x50, 0x4d, 0x18, 0x61,
+ 0xcd, 0x7e, 0xe5, 0xff, 0x18, 0x23, 0x30, 0xf1, 0x21, 0x07, 0xe9, 0x1b, 0x39,
+ 0x92, 0xe2, 0x89, 0x09, 0x82, 0x58, 0x94, 0x77, 0x42, 0xc7, 0xcb, 0x0d, 0xbd,
+ 0xa9, 0x74, 0xc6, 0xda, 0x37, 0xc3, 0x1f, 0x94, 0x55, 0x6e, 0xb4, 0x55, 0xe9,
+ 0x08, 0x75, 0x72, 0xe9, 0x23, 0x93, 0x17, 0xcd, 0x0b, 0x0e, 0xdd, 0x31,
+ ]
+ ),
+ test_case!(
+ [
+ 0x43, 0xe9, 0x04, 0x00, 0x8a, 0x82, 0x9b, 0x5d, 0x3b, 0xe6, 0x0d, 0x86, 0x6e,
+ 0x0a, 0x66, 0x28, 0xee, 0xed, 0xc2, 0xf3, 0x1c, 0x7b, 0xc2, 0x52, 0x6f, 0x63,
+ 0xb8, 0x0c, 0xa4, 0xed, 0xbb, 0xa2, 0x6b, 0x54, 0xf1, 0xdb, 0xb9, 0x1f, 0x8e,
+ 0x69, 0x8f, 0xb0, 0x35, 0x68, 0xed, 0xdd, 0x71, 0x6f, 0x90, 0x1a, 0x47, 0x9f,
+ 0x59, 0xb2, 0xda, 0xf2, 0x68, 0x3d, 0xa2, 0xa6, 0xe3, 0x34, 0x2b, 0x10, 0x0c,
+ 0x76, 0xe0, 0x86, 0x4f, 0x14, 0xa1, 0xcd, 0xc5, 0xa5, 0x7e, 0x36, 0xb4, 0xa5,
+ 0x12, 0x01, 0xb1, 0x9e, 0xbb, 0x78, 0x0c, 0x9a, 0x4e, 0x02, 0xc4, 0x54, 0x22,
+ 0x99,
+ ],
+ [
+ 0x21, 0xd0, 0xf2, 0xcd, 0x12, 0xcc, 0x7d, 0x73, 0xd4, 0x29, 0x7a, 0x29, 0xbc,
+ 0xdf, 0xfd, 0x39, 0xc6, 0x39, 0x4b, 0x36,
+ ],
+ [
+ 0x1d, 0x28, 0xb5, 0x20, 0xfa, 0xb1, 0xc0, 0xae, 0x6f, 0xcf, 0x8f, 0xd0, 0xe1,
+ 0xa9, 0xdc, 0x5b, 0x59, 0xae, 0x47, 0xf3, 0xff, 0xa2, 0x2b, 0xdf, 0xb0, 0x68,
+ 0x91, 0xde, 0xf3, 0x05, 0x1b, 0xf4,
+ ],
+ [
+ 0x43, 0x11, 0xfb, 0xf9, 0xf2, 0x79, 0x96, 0x74, 0xc5, 0x5c, 0xd9, 0xc1, 0xa1,
+ 0xbb, 0x51, 0x21, 0x5f, 0x89, 0xac, 0xc8, 0xaf, 0x83, 0x85, 0x53, 0x13, 0xa7,
+ 0x67, 0x3f, 0x09, 0x67, 0x33, 0x15, 0xab, 0xf1, 0xfd, 0x67, 0x5d, 0x0b, 0x6b,
+ 0x20, 0x8d, 0x59, 0x2c, 0x61, 0xa4, 0x29, 0x8a, 0x33,
+ ],
+ [
+ 0x62, 0xc7, 0x01, 0xa7, 0xdb, 0x46, 0xdf, 0x1c, 0x04, 0xd0, 0x11, 0x71, 0xab,
+ 0x08, 0x13, 0x01, 0x61, 0x24, 0x44, 0x8b, 0xda, 0xc2, 0xc1, 0x90, 0x9f, 0x1c,
+ 0xdf, 0x76, 0xa3, 0x4f, 0x27, 0x83, 0x26, 0x3b, 0x9d, 0xda, 0x20, 0x56, 0x83,
+ 0x31, 0x47, 0x6d, 0x33, 0xf2, 0x44, 0xe0, 0x1c, 0x5c, 0xce, 0x55, 0x99, 0xd3,
+ 0x6b, 0xd0, 0x1b, 0x31, 0xb0, 0x14, 0x1d, 0xf2, 0xfa, 0xa8, 0x01, 0xfa,
+ ]
+ ),
+ test_case!(
+ [
+ 0x73, 0x32, 0xc6, 0x58, 0x9e, 0xa1, 0x1f, 0x59, 0xe4, 0x61, 0xd1, 0x7a, 0xa7,
+ 0xbd, 0xf4, 0x15, 0xd1, 0x1c, 0xae, 0x71, 0xd2, 0x0c, 0x14, 0x15, 0xb3, 0x7d,
+ 0xe6, 0x03, 0x12, 0xb4, 0x2f, 0xec, 0x6a, 0xcf, 0x9c, 0x79, 0x18, 0xe8, 0xf3,
+ 0x85, 0x4c, 0x47, 0xfd, 0x02, 0xba, 0x77, 0x86, 0x81, 0x55, 0x03, 0x40, 0x6d,
+ 0x8e, 0x2c, 0x3c, 0x1c, 0x7f, 0x96, 0x9e, 0x5b, 0x6b, 0x39, 0x53, 0xcc, 0x5b,
+ 0xd9, 0x38, 0x47, 0xc8, 0xf3, 0xae, 0xef, 0x21, 0x22, 0x82, 0x1c, 0x12, 0x3d,
+ 0x49, 0xd1, 0x80, 0x1c, 0x8a, 0x26, 0x65, 0x8b, 0xd0, 0x1a, 0xcf, 0x0d, 0xf2,
+ 0x78, 0x55,
+ ],
+ [
+ 0x10, 0x17, 0x15, 0x4a, 0xf9, 0xee, 0xae, 0xc1, 0xc6, 0x0d, 0x3b, 0x10, 0xd1,
+ 0x47, 0xf7, 0xf1, 0x4b, 0xf4, 0x25, 0x3f,
+ ],
+ [
+ 0x4b, 0x59, 0x21, 0x3d, 0x09, 0xe8, 0x45, 0x2c, 0x9d, 0x66, 0xaf, 0x56, 0xc2,
+ 0x4a, 0x38, 0x02, 0xf1, 0xf9, 0x37, 0xc7, 0x45, 0xe9, 0x60, 0xe0, 0x1e, 0x2e,
+ 0xfc, 0x50, 0x0f, 0x83, 0x8b, 0x22,
+ ],
+ [
+ 0x0a, 0xc3, 0xe0, 0xb3, 0xb2, 0x3a, 0xf8, 0x05, 0xa3, 0xdf, 0x8c, 0x1d, 0x9c,
+ 0xa3, 0xd8, 0xd2, 0xe5, 0xb2, 0x18, 0x52, 0xe0, 0xd8, 0x77, 0x36, 0xa6, 0x0e,
+ 0x90, 0x38, 0x08, 0x27, 0xcf, 0xb9, 0xf3, 0x15, 0xd6, 0xf9, 0x73, 0x5a, 0xa8,
+ 0x52, 0xd8, 0x4a, 0xf5, 0xd6, 0x1c, 0x36, 0x56, 0x3f,
+ ],
+ [
+ 0xc1, 0x38, 0x0f, 0x19, 0xdc, 0xae, 0x59, 0x02, 0x85, 0xca, 0xe2, 0x3d, 0xf3,
+ 0xf1, 0x52, 0xa3, 0x7d, 0xfd, 0xe1, 0x19, 0x19, 0x01, 0x8f, 0x93, 0x30, 0x49,
+ 0xf3, 0x20, 0x27, 0xb3, 0x34, 0x27, 0x66, 0x8e, 0xfa, 0x19, 0xd9, 0xa1, 0xf4,
+ 0x8e, 0x83, 0x1d, 0x81, 0x93, 0x57, 0x32, 0x82, 0x2d, 0x4d, 0xfb, 0xf4, 0xbe,
+ 0x64, 0x2e, 0x70, 0x0f, 0xfd, 0x49, 0x5b, 0xce, 0xa9, 0xc2, 0x87, 0xbb,
+ ]
+ ),
+ test_case!(
+ [
+ 0x8d, 0x29, 0x27, 0x28, 0x29, 0x61, 0xb0, 0xc9, 0xab, 0x3e, 0x06, 0x13, 0x1b,
+ 0x26, 0xac, 0x3e, 0xde, 0x6f, 0x45, 0x55, 0xf2, 0x22, 0x9d, 0xf8, 0x65, 0x1c,
+ 0x2e, 0xfc, 0x7e, 0x68, 0x46, 0xf4, 0x7b, 0x07, 0xb1, 0xc6, 0xc2, 0x29, 0xdc,
+ 0x04, 0xdd, 0x5d, 0xff, 0x47, 0x95, 0x10, 0x59, 0xab, 0x16, 0x86, 0x3b, 0x45,
+ 0x5b, 0x7b, 0x54, 0x7f, 0xc0, 0x0d, 0x8a, 0xe9, 0x0a, 0xb8, 0xc9, 0x93, 0xda,
+ 0xb8, 0x51, 0xb8, 0xbe, 0xb9, 0xf4, 0x8b, 0xee, 0x74, 0x26, 0xac, 0x4c, 0xbb,
+ 0xb3, 0xfd, 0x71, 0xf6, 0x9f, 0xff, 0xac, 0x13, 0x7e, 0x4d, 0xa1, 0xa7, 0x64,
+ 0x66, 0xd9, 0x2c,
+ ],
+ [
+ 0xf6, 0x43, 0x95, 0xf1, 0x92, 0xc2, 0xd5, 0xae, 0xe3, 0x2c, 0x54, 0xb3, 0x12,
+ 0xe9, 0x54, 0x28, 0xf6, 0x81, 0x5a, 0xc4,
+ ],
+ [
+ 0x47, 0xf6, 0x91, 0xf4, 0xd2, 0x11, 0x2f, 0xb6, 0xc4, 0xba, 0xf8, 0xce, 0xf2,
+ 0xff, 0x98, 0x67, 0xfa, 0xb7, 0x41, 0xbe, 0xe5, 0x55, 0xec, 0xae, 0x34, 0x70,
+ 0xd6, 0x11, 0xba, 0x21, 0xe7, 0x24,
+ ],
+ [
+ 0xa6, 0xaa, 0xd9, 0x37, 0x0a, 0x08, 0xe4, 0xde, 0x3b, 0x00, 0x8f, 0xeb, 0x98,
+ 0x51, 0x95, 0x99, 0xe0, 0x35, 0x5d, 0x0f, 0x2d, 0xee, 0x49, 0x4a, 0x59, 0x9d,
+ 0xe9, 0xef, 0xeb, 0xfd, 0x76, 0xcb, 0x7a, 0xec, 0x77, 0xa6, 0x70, 0x87, 0xc5,
+ 0xec, 0x44, 0x57, 0x79, 0xc3, 0xa2, 0xce, 0xc1, 0x18,
+ ],
+ [
+ 0xa4, 0xd0, 0x67, 0x30, 0x6c, 0x32, 0xde, 0xbe, 0x21, 0x8c, 0xb6, 0x01, 0x3b,
+ 0xe8, 0xa0, 0xc5, 0xa7, 0xff, 0xf6, 0xcd, 0x35, 0x79, 0x95, 0x2e, 0xc6, 0xda,
+ 0x9b, 0x70, 0x80, 0x1e, 0x07, 0xdb, 0x13, 0x28, 0x93, 0x0e, 0xa0, 0x26, 0x3c,
+ 0x7e, 0x86, 0x6b, 0x45, 0xb9, 0x38, 0x99, 0xd8, 0x38, 0x54, 0xc9, 0x5e, 0x35,
+ 0x47, 0xc0, 0xc0, 0x44, 0x46, 0x94, 0xf9, 0x3b, 0xf4, 0xbe, 0xe1, 0x89,
+ ]
+ ),
+ test_case!(
+ [
+ 0x4f, 0xd4, 0x06, 0x82, 0x8c, 0xe3, 0x8c, 0x86, 0x93, 0x63, 0x24, 0x0e, 0xac,
+ 0xa1, 0xe0, 0xb3, 0xf1, 0x5f, 0x10, 0xa5, 0x30, 0x51, 0xed, 0xfe, 0xed, 0x66,
+ 0x07, 0x71, 0x8f, 0x18, 0x0c, 0x8b, 0x53, 0xc1, 0x5e, 0xec, 0xd2, 0xa0, 0x32,
+ 0x1b, 0x5e, 0xb6, 0x9b, 0x06, 0xd3, 0xf4, 0x7f, 0xf3, 0xcd, 0xc4, 0x1f, 0x39,
+ 0x4c, 0x2b, 0xf1, 0xfc, 0x00, 0x0b, 0xf1, 0x65, 0x0e, 0x81, 0x41, 0x08, 0x9a,
+ 0x57, 0xa4, 0x93, 0x33, 0x1e, 0xac, 0x42, 0x14, 0xe3, 0xc9, 0x2e, 0x84, 0x7a,
+ 0xaa, 0x2e, 0x5d, 0x24, 0x62, 0xd6, 0x42, 0xd5, 0x72, 0xb7, 0x75, 0xe5, 0x90,
+ 0xc5, 0x3a, 0x43, 0xb7,
+ ],
+ [
+ 0x02, 0x23, 0xd7, 0x82, 0xd3, 0xbc, 0x1a, 0x71, 0x64, 0x73, 0xb6, 0x0c, 0xba,
+ 0x06, 0x42, 0x38, 0x41, 0x89, 0xb4, 0x87,
+ ],
+ [
+ 0xd5, 0x62, 0xb6, 0x1c, 0xc5, 0xaa, 0x4d, 0xd6, 0x82, 0xb8, 0x9f, 0xd4, 0xa4,
+ 0x21, 0xdd, 0x98, 0xdc, 0x04, 0x2e, 0x64, 0xb1, 0x05, 0xe3, 0xfd, 0x4f, 0xa0,
+ 0x8e, 0x0c, 0x30, 0x2e, 0x45, 0xe2,
+ ],
+ [
+ 0x46, 0xb2, 0x59, 0x57, 0x65, 0xff, 0x15, 0xaf, 0xf3, 0x6f, 0xc6, 0xc5, 0x5f,
+ 0x6c, 0x8a, 0xbc, 0xc8, 0xbe, 0x73, 0x4b, 0xab, 0x22, 0xff, 0x07, 0xb4, 0x84,
+ 0x0e, 0x94, 0x5c, 0x99, 0x37, 0xa0, 0xa6, 0xdc, 0x6e, 0xef, 0xb6, 0x11, 0xf4,
+ 0x57, 0x38, 0x0e, 0xeb, 0x6a, 0x75, 0x62, 0xdd, 0x36,
+ ],
+ [
+ 0x35, 0x70, 0x74, 0xd9, 0x81, 0xb9, 0xaa, 0x7d, 0x1d, 0xb3, 0x59, 0x5f, 0x24,
+ 0x2c, 0xe5, 0xb8, 0xe3, 0xf1, 0x3c, 0x28, 0x2f, 0x00, 0x3c, 0xcc, 0x31, 0x8e,
+ 0x0f, 0x7e, 0xc9, 0xf0, 0xf4, 0x33, 0x74, 0xc4, 0x9d, 0x8f, 0xa5, 0x9a, 0x57,
+ 0xae, 0x9b, 0xb5, 0xc9, 0x60, 0x87, 0xdd, 0xb8, 0x4b, 0x75, 0xb9, 0x43, 0xd0,
+ 0x72, 0x68, 0xd3, 0xf9, 0x82, 0x23, 0xba, 0x8d, 0xf6, 0xc3, 0x05, 0x3a,
+ ]
+ ),
+ test_case!(
+ [
+ 0x32, 0xac, 0x0f, 0x42, 0x50, 0x87, 0xb6, 0x4d, 0x46, 0x68, 0xfc, 0xe9, 0x04,
+ 0x51, 0xe7, 0x72, 0x6b, 0x63, 0x33, 0x37, 0x7c, 0x0c, 0xd1, 0xd2, 0x93, 0x8a,
+ 0x11, 0xab, 0x96, 0x98, 0xbe, 0x7d, 0xd4, 0x22, 0xb1, 0x69, 0xd3, 0x1b, 0x3f,
+ 0x17, 0x3a, 0x7f, 0x96, 0x71, 0x82, 0xe4, 0x71, 0xd2, 0x36, 0x04, 0x8d, 0xc1,
+ 0x27, 0xb2, 0xbb, 0x80, 0xb7, 0xf2, 0x82, 0xfe, 0x9e, 0xa3, 0x9b, 0xc9, 0xda,
+ 0xa5, 0x61, 0x40, 0x1e, 0xdc, 0xd2, 0x3f, 0x17, 0xb2, 0x4a, 0xa2, 0x86, 0x5b,
+ 0x1e, 0x6f, 0xfa, 0x2f, 0x80, 0x9c, 0xe0, 0xc1, 0x3f, 0x00, 0x36, 0xbd, 0x3b,
+ 0x01, 0xf4, 0xe6, 0x7e, 0x74,
+ ],
+ [
+ 0x84, 0x27, 0xdf, 0xa6, 0x8c, 0x10, 0xdd, 0x14, 0x8b, 0x90, 0xb2, 0x74, 0xbc,
+ 0x54, 0xee, 0x7b, 0x93, 0x06, 0xda, 0x0b,
+ ],
+ [
+ 0xeb, 0x4f, 0x8d, 0x22, 0xdb, 0x7d, 0x47, 0xd7, 0x8c, 0x8d, 0xfc, 0x4a, 0x74,
+ 0x62, 0xcc, 0x95, 0xb3, 0x04, 0xfa, 0x51, 0x08, 0xfa, 0x54, 0x34, 0xcb, 0x6c,
+ 0x87, 0xe5, 0x58, 0x8b, 0xcc, 0x7f,
+ ],
+ [
+ 0x70, 0x1d, 0x91, 0x59, 0xbc, 0xd6, 0xdd, 0xa7, 0xc5, 0xd6, 0xc4, 0x1d, 0xeb,
+ 0x4b, 0xd9, 0x5d, 0xc9, 0x62, 0xb2, 0x7b, 0x2b, 0xce, 0xd2, 0x7f, 0x3a, 0x4c,
+ 0x0a, 0xd9, 0x7a, 0x90, 0xef, 0x9b, 0x80, 0x89, 0xd2, 0xed, 0x0d, 0x37, 0xbd,
+ 0x3e, 0x26, 0x1d, 0x10, 0x87, 0xac, 0x72, 0xaa, 0x2b,
+ ],
+ [
+ 0x3d, 0x7e, 0xc4, 0x53, 0xd4, 0x22, 0xcd, 0xcb, 0x43, 0xd6, 0x1f, 0xce, 0xab,
+ 0xbd, 0x40, 0xbf, 0x90, 0x69, 0xa3, 0x26, 0x72, 0x3f, 0xdb, 0xb3, 0x94, 0x4d,
+ 0x0f, 0x21, 0x20, 0xd2, 0x28, 0x35, 0x94, 0x69, 0xf0, 0xac, 0xba, 0xd2, 0xb6,
+ 0xb0, 0xeb, 0x34, 0x8f, 0x5e, 0x80, 0x0d, 0xf8, 0x71, 0x03, 0x0d, 0x3b, 0x42,
+ 0xac, 0x66, 0x2e, 0xc6, 0xac, 0x5a, 0x6c, 0xc1, 0x0c, 0x3f, 0x07, 0xb7,
+ ]
+ ),
+ test_case!(
+ [
+ 0xdf, 0xcd, 0x4f, 0x4c, 0x0b, 0x6a, 0x78, 0x2b, 0xe5, 0xda, 0x7d, 0x9e, 0x79,
+ 0xeb, 0x73, 0x7c, 0x4c, 0x84, 0xae, 0xf1, 0x5e, 0x90, 0xd1, 0xd1, 0xa6, 0x6a,
+ 0x3b, 0xc0, 0x43, 0x77, 0x64, 0x6c, 0x25, 0xd7, 0x04, 0x71, 0xc6, 0xf0, 0x89,
+ 0xbf, 0x22, 0x7b, 0xa6, 0x3e, 0x37, 0xad, 0xd5, 0xc6, 0xd1, 0xb4, 0xf3, 0x75,
+ 0x44, 0xda, 0xa7, 0xf4, 0x90, 0xea, 0xc2, 0xf6, 0x5c, 0x24, 0xab, 0xa0, 0xed,
+ 0x08, 0xe4, 0xf7, 0x9b, 0xb1, 0xc8, 0x8d, 0x9d, 0x81, 0x2d, 0x90, 0x57, 0x89,
+ 0x74, 0x4c, 0x66, 0xbd, 0x8e, 0xd2, 0x99, 0x2a, 0x11, 0x2a, 0x6e, 0xf6, 0x12,
+ 0x2f, 0xf3, 0x75, 0xee, 0x48, 0xd3,
+ ],
+ [
+ 0xf9, 0x60, 0xa4, 0x5e, 0xc2, 0x4a, 0xfc, 0xee, 0xd5, 0x91, 0xf8, 0x83, 0x0c,
+ 0x99, 0xa8, 0x5d, 0xd6, 0x08, 0x10, 0xd3,
+ ],
+ [
+ 0xe7, 0xbf, 0xf6, 0xb7, 0xd9, 0x6d, 0x92, 0x7d, 0x20, 0xa7, 0x15, 0x4e, 0x60,
+ 0x68, 0x22, 0x4f, 0x9f, 0x9a, 0x87, 0x0e, 0x72, 0x0c, 0x9a, 0x7e, 0x19, 0xda,
+ 0x6f, 0x80, 0x86, 0x09, 0x14, 0x19,
+ ],
+ [
+ 0x5c, 0x9c, 0xed, 0xdd, 0x66, 0xa7, 0x10, 0x8a, 0x9d, 0x5c, 0x7d, 0x84, 0xbb,
+ 0x69, 0x12, 0x23, 0xb1, 0xbf, 0xd0, 0x13, 0xa8, 0xc8, 0x97, 0x12, 0x3b, 0x73,
+ 0xeb, 0x82, 0xea, 0xd1, 0x06, 0xb3, 0xb7, 0x62, 0xc4, 0xc4, 0x5e, 0xd4, 0xcb,
+ 0xd2, 0x07, 0x61, 0x8f, 0xbf, 0x8d, 0x69, 0x35, 0xf8,
+ ],
+ [
+ 0x52, 0x40, 0xa2, 0xf5, 0xa2, 0x90, 0x47, 0xc7, 0xaa, 0x86, 0x80, 0x2b, 0x84,
+ 0x29, 0x99, 0x33, 0x96, 0x7c, 0xf8, 0xc7, 0xef, 0xe3, 0x4d, 0x89, 0x57, 0xd7,
+ 0xe7, 0xc9, 0xd7, 0xe1, 0x7d, 0xbc, 0x71, 0xb6, 0x13, 0x1b, 0x50, 0x3a, 0x2a,
+ 0x0a, 0xcf, 0x60, 0x02, 0x34, 0x62, 0xdf, 0x22, 0xe1, 0x1a, 0xd9, 0xa5, 0x8d,
+ 0x7d, 0xa6, 0xea, 0xb9, 0x0e, 0x38, 0xa6, 0xdc, 0xe0, 0x9e, 0x82, 0xb4,
+ ]
+ ),
+ test_case!(
+ [
+ 0xcb, 0x50, 0x7c, 0x8b, 0x3c, 0x2d, 0x89, 0xbb, 0x93, 0xf3, 0xe6, 0xee, 0xd4,
+ 0x53, 0x13, 0xa1, 0xeb, 0xb6, 0x3f, 0x76, 0x01, 0x90, 0xda, 0x57, 0x32, 0x73,
+ 0xa3, 0x12, 0x0a, 0xd4, 0x09, 0x6e, 0x14, 0xd7, 0x7d, 0xb4, 0xfe, 0xc4, 0x09,
+ 0x9d, 0x06, 0x9d, 0xe9, 0xb8, 0xf8, 0xce, 0x12, 0xe6, 0xf2, 0x5d, 0x36, 0x1d,
+ 0x3d, 0xf3, 0x4b, 0x74, 0x7e, 0xfa, 0xbf, 0x41, 0x41, 0xa6, 0x82, 0xf2, 0x21,
+ 0x25, 0x99, 0xf8, 0x03, 0xaa, 0x4d, 0x3d, 0x08, 0x61, 0x5c, 0xb8, 0x40, 0x6c,
+ 0xc8, 0xda, 0x53, 0x69, 0xe4, 0xb3, 0xbb, 0x7c, 0x30, 0x41, 0x16, 0x87, 0xee,
+ 0x55, 0x7d, 0xe3, 0xfc, 0x4e, 0x8e, 0x7f,
+ ],
+ [
+ 0xdf, 0xfe, 0x3c, 0x28, 0x51, 0xd1, 0x81, 0x34, 0x7d, 0x83, 0x22, 0x65, 0xfb,
+ 0xbb, 0x75, 0x70, 0x36, 0x63, 0x2e, 0xb4,
+ ],
+ [
+ 0x2c, 0x68, 0x29, 0x0f, 0x2e, 0xe7, 0xe0, 0x95, 0x4e, 0x0a, 0xbf, 0x48, 0x05,
+ 0x9c, 0xd4, 0x99, 0x68, 0xdf, 0x1f, 0x5f, 0x08, 0xb4, 0xa8, 0x3b, 0x44, 0xf3,
+ 0x24, 0xfd, 0x86, 0x08, 0xa9, 0x1b,
+ ],
+ [
+ 0xe2, 0x21, 0xb1, 0x6d, 0xfc, 0x5a, 0x4d, 0xd2, 0xac, 0xa0, 0xcf, 0xae, 0xc6,
+ 0x6a, 0x88, 0xcd, 0xe5, 0x27, 0x14, 0xa7, 0xed, 0x3b, 0x8a, 0x12, 0x2a, 0xa9,
+ 0x21, 0xec, 0x71, 0x28, 0xc9, 0xf0, 0x24, 0xe8, 0xc2, 0x43, 0x90, 0xb1, 0xbc,
+ 0xd8, 0xd4, 0x0c, 0xdd, 0x15, 0x6f, 0xab, 0x1c, 0x99,
+ ],
+ [
+ 0x6f, 0xac, 0x6c, 0xc0, 0x70, 0xe7, 0x48, 0x9a, 0xd9, 0x37, 0xec, 0x29, 0xb9,
+ 0xe0, 0x56, 0x45, 0x5f, 0xe0, 0xf9, 0xfc, 0x1d, 0x13, 0x24, 0xd2, 0xca, 0x85,
+ 0x4f, 0x3e, 0x47, 0x4c, 0xd8, 0x0d, 0x22, 0x56, 0x5d, 0xea, 0x9e, 0xf2, 0x6c,
+ 0xc3, 0x9a, 0x41, 0x9e, 0xf7, 0xbe, 0x7a, 0x20, 0x45, 0x51, 0x00, 0x6d, 0x76,
+ 0x2a, 0x80, 0x96, 0x00, 0xb6, 0xe8, 0x41, 0xfa, 0xcc, 0xe1, 0x72, 0xb5,
+ ]
+ ),
+ test_case!(
+ [
+ 0x17, 0x3e, 0x54, 0xa8, 0x59, 0x6f, 0xad, 0x91, 0xd0, 0x43, 0x82, 0x36, 0xd4,
+ 0x21, 0xd1, 0x6c, 0x90, 0x12, 0x57, 0x86, 0xf2, 0x5d, 0x6c, 0x56, 0x05, 0xf6,
+ 0x88, 0xf6, 0x8a, 0xe1, 0x59, 0x4f, 0x16, 0x6d, 0xb0, 0xdb, 0x01, 0xbd, 0x61,
+ 0x75, 0x86, 0x49, 0xc1, 0x85, 0xa1, 0xcb, 0xb0, 0x3a, 0x55, 0xa3, 0x6f, 0xb9,
+ 0x86, 0xf4, 0xd8, 0xaf, 0xc9, 0x98, 0xf0, 0x25, 0x5b, 0xc1, 0x78, 0x58, 0x18,
+ 0x42, 0xae, 0x1d, 0xd2, 0x75, 0xac, 0xe9, 0x15, 0x5f, 0x4e, 0x68, 0xe4, 0x58,
+ 0x22, 0x66, 0x42, 0x68, 0x98, 0xaa, 0x04, 0xa3, 0x89, 0x24, 0xbd, 0xdd, 0x06,
+ 0xa9, 0x8c, 0x06, 0x74, 0xe4, 0x32, 0x74, 0xf1,
+ ],
+ [
+ 0x9e, 0x1f, 0x91, 0xda, 0x68, 0x85, 0xf7, 0xa1, 0x18, 0x88, 0x66, 0x71, 0x0d,
+ 0xfd, 0x87, 0xd7, 0x22, 0xc2, 0xf0, 0x58,
+ ],
+ [
+ 0x6f, 0x06, 0x6d, 0xd5, 0xe8, 0x07, 0xbd, 0x8e, 0xfa, 0xb0, 0x1a, 0x2e, 0xce,
+ 0x00, 0x30, 0x52, 0x62, 0xf6, 0xc8, 0xab, 0xfc, 0xdb, 0xd8, 0xae, 0xb4, 0x95,
+ 0x15, 0x9f, 0x87, 0xf8, 0x5b, 0x92,
+ ],
+ [
+ 0x79, 0x99, 0x0a, 0x40, 0x88, 0xe5, 0x88, 0xe6, 0x94, 0x58, 0x76, 0xe4, 0x08,
+ 0x6e, 0x12, 0x20, 0xe5, 0x23, 0xf3, 0x43, 0xa8, 0x12, 0xee, 0xf0, 0xa1, 0x2e,
+ 0xc4, 0xc7, 0x0e, 0xf3, 0x05, 0xbf, 0x16, 0xac, 0xf7, 0x41, 0x52, 0xa9, 0x94,
+ 0x4c, 0xac, 0x68, 0xcb, 0x42, 0x6d, 0x81, 0x3a, 0xdf,
+ ],
+ [
+ 0xe5, 0xf4, 0x45, 0xba, 0xaa, 0x0e, 0x51, 0x2f, 0x3d, 0x1f, 0x9b, 0x23, 0x5b,
+ 0x7c, 0xb3, 0xf2, 0x20, 0x1e, 0x70, 0x2a, 0x30, 0x7c, 0x14, 0x1a, 0x26, 0x07,
+ 0x7f, 0x8d, 0xed, 0x4c, 0x9a, 0x7b, 0xbd, 0x3d, 0x96, 0x8e, 0x86, 0x99, 0xec,
+ 0xac, 0x70, 0xf1, 0x38, 0xef, 0xb3, 0x37, 0x8f, 0x20, 0xf9, 0x78, 0x4b, 0xcf,
+ 0xef, 0x4e, 0x67, 0x03, 0x96, 0x3d, 0x50, 0x39, 0x15, 0xa5, 0xc5, 0x43,
+ ]
+ ),
+ test_case!(
+ [
+ 0x95, 0x16, 0x49, 0xb0, 0x8b, 0x66, 0xb9, 0xdf, 0x54, 0x27, 0xec, 0x3f, 0xa1,
+ 0xcb, 0xf5, 0x74, 0x13, 0x7d, 0x85, 0xcc, 0xc4, 0xab, 0xea, 0x3c, 0xad, 0x93,
+ 0x66, 0xe6, 0xe3, 0xf4, 0x6b, 0x70, 0x13, 0xa6, 0xed, 0xdb, 0xd3, 0xdb, 0x6d,
+ 0x1a, 0x7b, 0xbc, 0x3f, 0x93, 0xe7, 0xd3, 0xbc, 0xb3, 0x2e, 0xa8, 0xb5, 0x26,
+ 0xdd, 0xd4, 0x8a, 0x01, 0x11, 0x02, 0xfe, 0x39, 0xf3, 0x44, 0xc6, 0xe9, 0x01,
+ 0xf2, 0x19, 0x73, 0x57, 0x29, 0x84, 0x50, 0x4b, 0x63, 0x18, 0xcd, 0xf8, 0xfe,
+ 0x24, 0xbd, 0x40, 0x9f, 0x9f, 0xad, 0x29, 0x23, 0xd9, 0x9d, 0xb1, 0x38, 0x19,
+ 0x68, 0x1b, 0x56, 0x5f, 0xb0, 0xe7, 0x00, 0x9d, 0x28,
+ ],
+ [
+ 0x6c, 0x92, 0x43, 0xc3, 0xc9, 0xb4, 0x0f, 0xbb, 0x7e, 0x2b, 0xd9, 0x46, 0x52,
+ 0x87, 0x9a, 0x8b, 0xfe, 0x19, 0x20, 0x01,
+ ],
+ [
+ 0x26, 0x2b, 0x4e, 0x0a, 0xc3, 0xbe, 0x32, 0xe6, 0xf3, 0x3f, 0xf4, 0x77, 0x38,
+ 0x5d, 0xa8, 0x59, 0xf6, 0xff, 0xcb, 0x4a, 0x44, 0x0b, 0x02, 0x25, 0x58, 0x76,
+ 0xce, 0x94, 0xfc, 0xad, 0xe1, 0xa4,
+ ],
+ [
+ 0x35, 0xba, 0x1b, 0x0a, 0x8a, 0x1d, 0x2a, 0x23, 0x97, 0x3a, 0x77, 0x79, 0x63,
+ 0xa9, 0x28, 0xd7, 0xbd, 0xdc, 0x14, 0xd5, 0x33, 0x40, 0xd0, 0xd1, 0x42, 0x6e,
+ 0x85, 0x6a, 0xc4, 0x25, 0x75, 0xe3, 0xf9, 0x9b, 0x14, 0xba, 0xbb, 0x8b, 0x02,
+ 0x1d, 0x84, 0x95, 0x2a, 0x73, 0xec, 0x32, 0xc5, 0xfa,
+ ],
+ [
+ 0xa6, 0xb8, 0x42, 0xde, 0xae, 0xb0, 0xc1, 0x83, 0x02, 0x30, 0x93, 0xbd, 0x33,
+ 0xf0, 0x0e, 0x4a, 0x77, 0x2e, 0x1d, 0xd8, 0x0a, 0x8d, 0x06, 0xeb, 0x51, 0x58,
+ 0xc7, 0x4c, 0x62, 0x7f, 0x64, 0x53, 0xf2, 0x4b, 0xa3, 0x05, 0xfe, 0xd8, 0xf5,
+ 0x07, 0xd7, 0x37, 0xbb, 0x79, 0x9b, 0xce, 0xc5, 0xde, 0xff, 0x53, 0x45, 0x71,
+ 0x42, 0xd6, 0x5d, 0x74, 0x7a, 0x34, 0x06, 0x65, 0x20, 0x48, 0xe4, 0xd8,
+ ]
+ ),
+ test_case!(
+ [
+ 0xf2, 0x6c, 0x71, 0xc0, 0xb3, 0x38, 0x23, 0x77, 0x86, 0xb9, 0xb1, 0x73, 0x37,
+ 0x85, 0x2d, 0x57, 0x21, 0xb1, 0xfd, 0x8b, 0x3d, 0x39, 0xb0, 0xbd, 0x63, 0x5b,
+ 0xe2, 0x70, 0x6d, 0x44, 0x8b, 0x5a, 0xc9, 0x41, 0xc3, 0xc5, 0x31, 0x2c, 0xbe,
+ 0x88, 0x00, 0x96, 0x1c, 0x9a, 0x17, 0x8a, 0x39, 0x1b, 0x79, 0xf2, 0x0b, 0x39,
+ 0x1b, 0xa0, 0x90, 0xd8, 0x3f, 0xeb, 0xa8, 0x4a, 0xe1, 0x2f, 0x9e, 0x6a, 0x46,
+ 0x3b, 0xde, 0xe6, 0xdc, 0x3e, 0xd9, 0xd7, 0x92, 0x04, 0xe0, 0xe7, 0x0e, 0xea,
+ 0xea, 0x1e, 0x93, 0x0f, 0x32, 0x42, 0x4e, 0x4d, 0x69, 0x29, 0x78, 0x73, 0xf9,
+ 0xf1, 0x6c, 0x97, 0x09, 0x93, 0x23, 0xf2, 0x30, 0xab, 0x97,
+ ],
+ [
+ 0xae, 0xc0, 0x80, 0x77, 0x14, 0x2e, 0x6f, 0xcb, 0x6a, 0x79, 0xda, 0x28, 0x6c,
+ 0xd6, 0x0b, 0xd6, 0xb0, 0xc2, 0x3b, 0xc7,
+ ],
+ [
+ 0x23, 0x4d, 0x9d, 0x0c, 0xd3, 0x62, 0xc3, 0x7f, 0xf0, 0x81, 0x22, 0xee, 0x16,
+ 0xc9, 0x64, 0xf1, 0x06, 0xd8, 0x7b, 0x89, 0xf1, 0xb3, 0x8f, 0xa4, 0xde, 0x2d,
+ 0x1f, 0x83, 0xbd, 0x62, 0xff, 0x79,
+ ],
+ [
+ 0x1b, 0x2b, 0xcf, 0x3c, 0xe1, 0x1a, 0xc3, 0x3f, 0x46, 0x54, 0x81, 0xda, 0xea,
+ 0xc3, 0x13, 0x3b, 0x0d, 0x9d, 0x43, 0x77, 0x97, 0x3e, 0xe4, 0x61, 0x84, 0xad,
+ 0x55, 0x82, 0xe3, 0xa5, 0xea, 0xb6, 0x44, 0xf8, 0x52, 0x8d, 0xec, 0x64, 0x06,
+ 0x21, 0x47, 0x79, 0x6c, 0x65, 0x51, 0xeb, 0xa5, 0xaa,
+ ],
+ [
+ 0x07, 0xdb, 0x67, 0x19, 0xaa, 0x67, 0x3b, 0xe8, 0x22, 0xb6, 0x94, 0x66, 0x91,
+ 0x13, 0x58, 0x68, 0x0a, 0x90, 0x02, 0x4b, 0x86, 0x8b, 0x67, 0x81, 0x9d, 0xef,
+ 0xd6, 0x58, 0xc1, 0xb4, 0x43, 0x21, 0xfd, 0x01, 0x7b, 0x32, 0x60, 0x4d, 0x51,
+ 0x88, 0x0f, 0xf3, 0x52, 0x12, 0xca, 0x16, 0xd9, 0xfd, 0xb7, 0x32, 0x34, 0x5d,
+ 0x60, 0x23, 0x10, 0xbc, 0x11, 0xa3, 0x14, 0x4c, 0x96, 0x02, 0x22, 0xc8,
+ ]
+ ),
+ test_case!(
+ [
+ 0xb8, 0x4e, 0x8a, 0x14, 0x6c, 0x66, 0x13, 0x9d, 0x94, 0x1f, 0xe7, 0x0e, 0xc9,
+ 0xf4, 0xbe, 0x6e, 0x74, 0x3c, 0xaa, 0x1b, 0x02, 0x28, 0x15, 0xd9, 0xfb, 0x7e,
+ 0xee, 0xd9, 0x35, 0xc9, 0xd7, 0x2d, 0x0c, 0xa0, 0xb5, 0x7d, 0xf4, 0x9d, 0x39,
+ 0x3f, 0x51, 0xf0, 0x0b, 0x49, 0x65, 0xc5, 0x24, 0x21, 0xd4, 0x18, 0xa3, 0x80,
+ 0xcb, 0x1f, 0x86, 0x2a, 0x7f, 0x30, 0x9c, 0x86, 0x4e, 0x3e, 0x0f, 0xee, 0x8a,
+ 0x2e, 0x86, 0x22, 0x3c, 0xa2, 0x4a, 0xb0, 0x3f, 0xa0, 0x38, 0x91, 0x0f, 0x30,
+ 0x02, 0xed, 0x82, 0xb8, 0x24, 0xfc, 0x43, 0xf3, 0x3b, 0x5f, 0x1f, 0x43, 0xf0,
+ 0x44, 0x07, 0xd3, 0x9e, 0xd3, 0x27, 0x65, 0xa8, 0x76, 0x9e, 0x9c,
+ ],
+ [
+ 0x81, 0xc3, 0x45, 0xbf, 0xd7, 0xf9, 0xbb, 0x4b, 0x1f, 0x7a, 0xff, 0x58, 0x33,
+ 0x0a, 0x7c, 0x98, 0x25, 0x67, 0x40, 0xa4,
+ ],
+ [
+ 0xc8, 0xfd, 0x96, 0x57, 0xab, 0x18, 0x60, 0xf1, 0xca, 0xfe, 0x10, 0x54, 0x05,
+ 0x54, 0x07, 0xa9, 0x52, 0x03, 0x59, 0x94, 0x13, 0x26, 0x94, 0x8e, 0x79, 0x82,
+ 0xf4, 0xe6, 0xb8, 0x1f, 0x0c, 0xc5,
+ ],
+ [
+ 0x69, 0x6b, 0xf9, 0x28, 0x4a, 0x94, 0x27, 0x46, 0xf2, 0xc0, 0x98, 0xdb, 0x8d,
+ 0x7b, 0x9e, 0xe1, 0x90, 0x5f, 0xfc, 0x0f, 0xef, 0xe4, 0xa7, 0x5e, 0x99, 0xb8,
+ 0x92, 0xd8, 0x99, 0xcc, 0xdd, 0x38, 0xc1, 0xcf, 0x06, 0x00, 0x8e, 0x53, 0xb6,
+ 0xf6, 0x2d, 0xcf, 0xfb, 0xdc, 0x5b, 0xf5, 0x0e, 0xe3,
+ ],
+ [
+ 0x27, 0x8d, 0x60, 0x38, 0xee, 0xa1, 0x65, 0x8d, 0x45, 0x38, 0xd8, 0xf6, 0x9a,
+ 0x0d, 0x75, 0x07, 0xae, 0x39, 0x18, 0x29, 0xff, 0x87, 0x81, 0xb0, 0x57, 0x6f,
+ 0x11, 0x16, 0x17, 0xe1, 0xd0, 0xce, 0xcf, 0x09, 0xdb, 0xa4, 0xc8, 0x1d, 0xb8,
+ 0xba, 0xfa, 0x9d, 0xd0, 0xae, 0x1e, 0x19, 0xd6, 0x7a, 0x5a, 0x94, 0x58, 0x0c,
+ 0x89, 0xd8, 0xbb, 0xf3, 0xdc, 0x0d, 0x81, 0x38, 0x84, 0x08, 0xbc, 0x10,
+ ]
+ ),
+ test_case!(
+ [
+ 0x34, 0xfe, 0xcd, 0xb5, 0xe3, 0xb9, 0x02, 0x69, 0x78, 0x73, 0x4c, 0x24, 0xdb,
+ 0x6a, 0x47, 0xb9, 0xca, 0x9a, 0x2e, 0x37, 0xc6, 0xa5, 0x6b, 0xbe, 0x70, 0x01,
+ 0xf3, 0x24, 0x0a, 0xb2, 0xf2, 0x12, 0x1a, 0x7c, 0x51, 0xe7, 0x2b, 0x93, 0x5d,
+ 0xb5, 0xaf, 0xca, 0x12, 0x21, 0x6b, 0x4a, 0x29, 0x92, 0x2a, 0xe9, 0x84, 0x22,
+ 0x51, 0x5c, 0x4b, 0xf9, 0x93, 0x8c, 0xa4, 0xf9, 0x38, 0x27, 0x1d, 0x5a, 0xa5,
+ 0x6a, 0x8e, 0x9e, 0xb2, 0x18, 0xd0, 0xb6, 0x65, 0x2c, 0xea, 0x64, 0xbb, 0x5f,
+ 0x98, 0x6f, 0x5d, 0x17, 0xd5, 0x4b, 0x7b, 0xc7, 0x15, 0xb8, 0xfd, 0x99, 0x9e,
+ 0x31, 0x18, 0x4f, 0x1f, 0xb0, 0x54, 0x0b, 0xb6, 0x23, 0x4c, 0xad, 0x4d,
+ ],
+ [
+ 0x4d, 0xcb, 0x60, 0x4e, 0x5d, 0xf3, 0x75, 0x0d, 0x4a, 0x82, 0x2f, 0x0c, 0xc3,
+ 0x9f, 0x21, 0xea, 0xd8, 0xc3, 0x7d, 0xc3,
+ ],
+ [
+ 0xba, 0x2a, 0xd0, 0x06, 0xa5, 0xcb, 0x40, 0xab, 0xbc, 0xda, 0x10, 0xa8, 0x7c,
+ 0xf1, 0xca, 0xf8, 0xaa, 0x45, 0x11, 0x57, 0x3f, 0xab, 0x13, 0xdf, 0xe8, 0xa2,
+ 0x62, 0x38, 0xcd, 0x66, 0x80, 0x2f,
+ ],
+ [
+ 0x1d, 0x34, 0xbb, 0x19, 0x32, 0xe8, 0x77, 0xbf, 0x4c, 0x5b, 0x98, 0xab, 0x2d,
+ 0x54, 0x51, 0x0d, 0xde, 0x8c, 0x3f, 0x29, 0x03, 0x73, 0x10, 0x29, 0x65, 0xbc,
+ 0xe9, 0xd9, 0x67, 0x05, 0xb0, 0x8c, 0x2f, 0xf3, 0xe6, 0x34, 0x93, 0x9b, 0x43,
+ 0x50, 0x72, 0x74, 0x78, 0x30, 0x5a, 0x40, 0xd3, 0xb5,
+ ],
+ [
+ 0xac, 0xe5, 0xbe, 0xfd, 0x98, 0xa7, 0x7b, 0x12, 0xcf, 0x16, 0xa2, 0xec, 0x8e,
+ 0x6a, 0x75, 0x9a, 0x35, 0x8b, 0x1b, 0xab, 0x34, 0xc1, 0xb1, 0xd0, 0x02, 0x6b,
+ 0x6d, 0x8d, 0xff, 0x12, 0x92, 0xf0, 0x31, 0x7b, 0xdf, 0x2d, 0x2d, 0x1d, 0xb6,
+ 0x68, 0x56, 0x06, 0x5a, 0xcb, 0xf4, 0x54, 0x9d, 0x58, 0x61, 0xd6, 0x01, 0x05,
+ 0x32, 0x51, 0x1d, 0x4c, 0x7d, 0xb5, 0xbf, 0xbb, 0x7a, 0xf0, 0x95, 0x27,
+ ]
+ ),
+ test_case!(
+ [
+ 0xaf, 0x1f, 0x29, 0x3d, 0xb6, 0xdf, 0x72, 0x86, 0x8c, 0xcc, 0x90, 0x69, 0x0a,
+ 0x9b, 0x89, 0x80, 0xe7, 0xfa, 0xdc, 0xf1, 0x59, 0x19, 0xe2, 0xf5, 0xc6, 0x59,
+ 0xf6, 0xca, 0xc8, 0xa3, 0x75, 0x82, 0x11, 0x04, 0x45, 0x90, 0xae, 0xfc, 0xbb,
+ 0x23, 0x5e, 0xc4, 0x0f, 0x90, 0x7c, 0x9e, 0x19, 0xcf, 0x0a, 0x38, 0x55, 0x54,
+ 0x7e, 0xa2, 0xf4, 0x02, 0x8a, 0x6f, 0xb7, 0xda, 0xd8, 0x5a, 0x4a, 0x5d, 0x39,
+ 0xf0, 0xd2, 0x7d, 0xc0, 0x7d, 0xd9, 0xc0, 0x6a, 0x92, 0x15, 0x74, 0xbb, 0xa5,
+ 0x45, 0x2e, 0x91, 0x73, 0x7f, 0xef, 0x4a, 0xe7, 0x9a, 0x70, 0xa8, 0xb0, 0x6f,
+ 0x3c, 0x0e, 0x49, 0xbc, 0xd7, 0x72, 0xf9, 0xbe, 0x3a, 0xc3, 0xf1, 0x67, 0x1a,
+ ],
+ [
+ 0xf8, 0x13, 0xff, 0x91, 0x6c, 0x8a, 0xd3, 0xc0, 0x87, 0x4f, 0x54, 0x9d, 0xae,
+ 0x1f, 0x87, 0xf1, 0x51, 0x00, 0xc8, 0x89,
+ ],
+ [
+ 0x5f, 0x22, 0x70, 0x31, 0x1f, 0xf1, 0x75, 0x94, 0xd3, 0xaa, 0xe0, 0x90, 0xf6,
+ 0x73, 0x75, 0x01, 0xcf, 0x9b, 0xcc, 0xb4, 0x17, 0x39, 0x61, 0x4f, 0x4f, 0x0f,
+ 0x79, 0x42, 0xe9, 0x34, 0x8e, 0x30,
+ ],
+ [
+ 0x8a, 0x13, 0xf4, 0xd5, 0xf5, 0x49, 0x28, 0xe0, 0x7c, 0x8b, 0xa5, 0xf0, 0x76,
+ 0x05, 0x6d, 0x4e, 0x71, 0x80, 0x04, 0x88, 0x4f, 0x08, 0x35, 0x24, 0xce, 0xcd,
+ 0x50, 0x4e, 0xad, 0x92, 0x79, 0xe9, 0xbc, 0xad, 0xc4, 0x19, 0x9a, 0xf1, 0x03,
+ 0x78, 0x4f, 0xac, 0xfb, 0x95, 0x30, 0x18, 0x5e, 0x1b,
+ ],
+ [
+ 0x76, 0x4b, 0x82, 0xe8, 0xaa, 0x93, 0x07, 0x60, 0xfc, 0x1f, 0xd4, 0x56, 0x0b,
+ 0xd3, 0x1b, 0x0c, 0xe9, 0x77, 0x71, 0x13, 0xa4, 0x08, 0xb2, 0x6b, 0xb8, 0x0c,
+ 0xc2, 0xaf, 0x04, 0xaf, 0xbf, 0xfc, 0xdd, 0xf8, 0x44, 0x71, 0xc7, 0x54, 0x64,
+ 0x23, 0xa0, 0xaa, 0xc3, 0x65, 0x9f, 0x80, 0x1c, 0x7a, 0x99, 0x8d, 0x10, 0x4a,
+ 0xe2, 0xaf, 0x08, 0xb5, 0x51, 0x03, 0x18, 0xd9, 0x38, 0x54, 0x16, 0x0f,
+ ]
+ ),
+ test_case!(
+ [
+ 0x24, 0xbe, 0x49, 0x7a, 0x0f, 0x94, 0xef, 0x6e, 0x5a, 0x59, 0xf4, 0x22, 0xd2,
+ 0x27, 0x53, 0x71, 0xc8, 0x8b, 0x9b, 0x38, 0xb9, 0x97, 0x00, 0x6c, 0x42, 0x69,
+ 0x99, 0xb7, 0xf6, 0x35, 0x72, 0xcb, 0x1b, 0xce, 0xbb, 0x87, 0x7a, 0xde, 0xb0,
+ 0x13, 0xa3, 0xf5, 0x6b, 0x8d, 0x80, 0xc6, 0x96, 0x6e, 0x9f, 0xcf, 0xb9, 0x2a,
+ 0xda, 0xcf, 0xfd, 0xd7, 0x42, 0x0e, 0x74, 0xaf, 0xd2, 0x03, 0x34, 0x11, 0xe8,
+ 0x50, 0x23, 0xc8, 0xca, 0xf2, 0xaf, 0xf6, 0x9f, 0xe8, 0x38, 0x51, 0xa2, 0x7b,
+ 0xe1, 0xec, 0x90, 0x5b, 0x9e, 0xe4, 0xd9, 0x09, 0x53, 0xe3, 0xf3, 0xee, 0x70,
+ 0xa7, 0x0d, 0xb7, 0x6d, 0x1d, 0xc7, 0x2f, 0xdb, 0x79, 0xd3, 0x8b, 0x47, 0x09,
+ 0x11,
+ ],
+ [
+ 0x12, 0x9b, 0xea, 0x42, 0x3d, 0xaf, 0xbb, 0x70, 0x7a, 0x9f, 0xee, 0xfb, 0xb2,
+ 0xb6, 0xeb, 0xab, 0xc7, 0xc0, 0xeb, 0xbf,
+ ],
+ [
+ 0x5a, 0x2e, 0xaa, 0x59, 0x90, 0x6f, 0xa2, 0xb2, 0xa8, 0xff, 0x5d, 0xef, 0x8f,
+ 0x6f, 0xcd, 0x0e, 0xec, 0x9a, 0xd8, 0x2c, 0xf4, 0xb9, 0x1d, 0x1a, 0xea, 0xb7,
+ 0x31, 0x70, 0xf3, 0x12, 0xb7, 0x98,
+ ],
+ [
+ 0xc3, 0x5c, 0xbb, 0xe6, 0x8c, 0x6d, 0x60, 0x9d, 0x1c, 0x21, 0x59, 0x84, 0x48,
+ 0x2f, 0x27, 0x07, 0x59, 0x4e, 0xeb, 0x25, 0x95, 0x66, 0xfe, 0xa8, 0x9c, 0x22,
+ 0x6e, 0xb7, 0x32, 0x60, 0xb8, 0xdc, 0xc5, 0x9e, 0xd9, 0x90, 0x7a, 0xb1, 0xb8,
+ 0xcf, 0xf6, 0xf8, 0xca, 0x53, 0x2d, 0xce, 0xf2, 0x65,
+ ],
+ [
+ 0x46, 0xd2, 0xac, 0x35, 0xb6, 0x69, 0x81, 0x32, 0x9c, 0x95, 0x20, 0xc0, 0x3f,
+ 0x35, 0x2d, 0x5b, 0x89, 0x38, 0x5e, 0x13, 0xec, 0xb5, 0x4b, 0xd6, 0xea, 0xca,
+ 0x7b, 0xf8, 0xfe, 0x16, 0x27, 0x25, 0xda, 0xc6, 0xc4, 0x39, 0xa7, 0x68, 0x9c,
+ 0x56, 0xef, 0xaa, 0x23, 0xbe, 0xbd, 0x7f, 0xf9, 0x0b, 0x25, 0xbc, 0x47, 0xaa,
+ 0x4d, 0x23, 0x7c, 0x8b, 0x59, 0xbb, 0x9f, 0xfe, 0xfa, 0xc6, 0x90, 0x51,
+ ]
+ ),
+ test_case!(
+ [
+ 0xa6, 0xb8, 0xb6, 0x36, 0xb6, 0xc7, 0xf1, 0x2c, 0xcb, 0xc2, 0xba, 0x8c, 0x8c,
+ 0x43, 0xa3, 0x25, 0x18, 0xfa, 0xe1, 0xe7, 0x3e, 0x35, 0x30, 0x62, 0x5c, 0x01,
+ 0x96, 0x32, 0x8c, 0x6c, 0x54, 0xa7, 0xa5, 0xea, 0x61, 0x26, 0x68, 0x8b, 0xbf,
+ 0x4e, 0x62, 0xfc, 0x5c, 0xdd, 0x10, 0x36, 0x09, 0x8c, 0xde, 0x34, 0xf7, 0x55,
+ 0x84, 0x05, 0xc0, 0x7a, 0x54, 0x95, 0x31, 0x00, 0x71, 0x8b, 0x14, 0xa6, 0x1f,
+ 0x03, 0x97, 0xd0, 0x4b, 0xed, 0x4e, 0x12, 0x98, 0x01, 0x74, 0xe2, 0x85, 0x11,
+ 0x5a, 0x5f, 0xc6, 0xaf, 0xc2, 0xe0, 0x30, 0xdc, 0x6e, 0xb4, 0xf5, 0xc7, 0xc5,
+ 0x7c, 0x07, 0x29, 0x74, 0x11, 0xe9, 0xe8, 0x28, 0xb3, 0xde, 0x70, 0xe1, 0xba,
+ 0xaa, 0xad,
+ ],
+ [
+ 0xd9, 0x29, 0xd9, 0x92, 0xb9, 0xcd, 0x4b, 0x25, 0x89, 0xc2, 0x47, 0x58, 0xa2,
+ 0xfc, 0xa7, 0x77, 0xf7, 0x80, 0xa0, 0x48,
+ ],
+ [
+ 0x27, 0xff, 0x4a, 0xd2, 0xb4, 0x35, 0xcc, 0x2f, 0xe1, 0xf6, 0xcb, 0x1d, 0x6c,
+ 0xcc, 0xf6, 0xd2, 0xa3, 0xda, 0x77, 0x15, 0x23, 0x41, 0x0d, 0x1d, 0xf2, 0xe3,
+ 0xc5, 0x19, 0x46, 0xbd, 0xac, 0xa7,
+ ],
+ [
+ 0x25, 0x95, 0x1c, 0x36, 0x45, 0xc2, 0x45, 0xae, 0x0a, 0xec, 0xe0, 0xc3, 0xd1,
+ 0x39, 0xfd, 0xc9, 0xdd, 0x47, 0x49, 0x94, 0xbd, 0x26, 0x47, 0x2c, 0xf4, 0xcc,
+ 0x37, 0x6c, 0x60, 0xfe, 0x3f, 0xa2, 0x27, 0x1f, 0xfa, 0x18, 0xd2, 0xe5, 0x4b,
+ 0xfb, 0x97, 0xb6, 0x6f, 0xb1, 0x63, 0x4b, 0x99, 0x4a,
+ ],
+ [
+ 0x19, 0xb5, 0x16, 0x3d, 0x81, 0x16, 0x0c, 0x67, 0xe6, 0xdc, 0xc4, 0x38, 0x7a,
+ 0xa7, 0xe4, 0x85, 0xfc, 0xab, 0xc3, 0x70, 0x3d, 0x52, 0x4d, 0xf5, 0x74, 0x96,
+ 0xd5, 0x61, 0x17, 0xff, 0xeb, 0x73, 0x4c, 0xdc, 0x62, 0xd5, 0xf8, 0x55, 0x32,
+ 0x2f, 0x84, 0x10, 0x46, 0xe9, 0x4b, 0x3f, 0xce, 0x10, 0x3d, 0xe8, 0x35, 0x2c,
+ 0xf8, 0x6f, 0x6f, 0x6e, 0x5b, 0x3f, 0x00, 0xd3, 0x82, 0x9c, 0x21, 0x13,
+ ]
+ ),
+ test_case!(
+ [
+ 0x0a, 0x63, 0xf9, 0x5b, 0x0a, 0xe5, 0xc1, 0x2c, 0x5e, 0xe8, 0x7f, 0x5d, 0xfd,
+ 0x89, 0xe0, 0x9f, 0x75, 0x39, 0xe7, 0x0f, 0x1a, 0x40, 0x79, 0x66, 0x74, 0xf6,
+ 0x13, 0x8c, 0xf8, 0x6b, 0xd3, 0x9f, 0x57, 0xf4, 0x34, 0x77, 0xf1, 0x41, 0xac,
+ 0x5a, 0x1b, 0xeb, 0xf8, 0x35, 0x6f, 0x68, 0xf4, 0x3b, 0x9a, 0x0a, 0x53, 0xc3,
+ 0x2e, 0x2c, 0xba, 0x87, 0x4b, 0xc4, 0x6c, 0xba, 0xe1, 0xef, 0x84, 0x0a, 0x76,
+ 0x94, 0x81, 0x86, 0xd8, 0x78, 0x47, 0x5b, 0x7f, 0x35, 0xf9, 0x9e, 0xda, 0x02,
+ 0x10, 0xee, 0xc5, 0x4a, 0x96, 0x64, 0x7d, 0x70, 0x0e, 0x50, 0x2b, 0x21, 0xac,
+ 0x98, 0x20, 0x7f, 0xe2, 0xfc, 0x16, 0x4d, 0x89, 0xdb, 0x48, 0xb8, 0xd0, 0x78,
+ 0x63, 0x2d, 0xfd,
+ ],
+ [
+ 0xb7, 0xb1, 0xa8, 0x42, 0xf0, 0xea, 0x83, 0x15, 0xd3, 0x02, 0x88, 0x31, 0x57,
+ 0x87, 0x8c, 0x74, 0x00, 0xd0, 0x24, 0x2c,
+ ],
+ [
+ 0x53, 0x44, 0x81, 0x42, 0xcf, 0xe1, 0x18, 0x53, 0xa6, 0x73, 0xef, 0x5e, 0x4d,
+ 0xa1, 0x5c, 0xd3, 0x2d, 0x77, 0xdd, 0xea, 0x58, 0x80, 0xc4, 0xeb, 0x39, 0xff,
+ 0x7c, 0xc1, 0xc7, 0x53, 0x74, 0x78,
+ ],
+ [
+ 0xe6, 0x8b, 0xef, 0x2c, 0xef, 0xcd, 0xf6, 0x99, 0xcb, 0xdd, 0xac, 0xf4, 0xa5,
+ 0x94, 0xa0, 0xe6, 0xdb, 0xe8, 0x60, 0x7c, 0xc1, 0x7b, 0xfb, 0xa1, 0xd8, 0x0b,
+ 0x07, 0x63, 0x6c, 0xbb, 0x99, 0xae, 0x01, 0xc0, 0xbf, 0x51, 0xe4, 0x7c, 0x18,
+ 0x5a, 0xd6, 0xc0, 0xd4, 0xa7, 0xa4, 0x11, 0x15, 0xe8,
+ ],
+ [
+ 0xcb, 0x2e, 0xd1, 0x2d, 0xe8, 0x43, 0x9d, 0xf7, 0x0f, 0xfa, 0x12, 0x76, 0x54,
+ 0xb9, 0xd4, 0xd6, 0x20, 0xa0, 0xc8, 0xdd, 0xd7, 0xcc, 0xbe, 0xae, 0x39, 0xa8,
+ 0xdb, 0xe2, 0x55, 0xc9, 0xe4, 0x83, 0xf7, 0x90, 0xdb, 0x04, 0x38, 0x15, 0x40,
+ 0x76, 0x24, 0x2b, 0xea, 0xa7, 0x7c, 0xb4, 0xb6, 0x6c, 0x34, 0xde, 0xef, 0xcc,
+ 0x22, 0x73, 0xec, 0x0f, 0xf8, 0x8a, 0x92, 0xa9, 0x1a, 0x3a, 0xa9, 0x0e,
+ ]
+ ),
+ test_case!(
+ [
+ 0x04, 0x0e, 0x7b, 0x1d, 0x79, 0xca, 0x81, 0x53, 0x70, 0xe0, 0x94, 0xbd, 0x16,
+ 0x75, 0xc1, 0xa2, 0x44, 0x14, 0x2a, 0xb8, 0x6b, 0x50, 0x46, 0x66, 0x5e, 0xc1,
+ 0x92, 0x27, 0xd1, 0x6d, 0xc3, 0x8a, 0x70, 0x25, 0x60, 0x42, 0xd2, 0xd9, 0x5c,
+ 0xc1, 0x8a, 0x3d, 0x22, 0xad, 0x55, 0xfe, 0xe6, 0xa8, 0xe6, 0x31, 0x66, 0x9c,
+ 0x68, 0x9f, 0x0b, 0x53, 0xf0, 0x7e, 0x46, 0xe6, 0x20, 0x5b, 0x0f, 0x1e, 0xe4,
+ 0x26, 0xd8, 0x23, 0x33, 0x65, 0x42, 0x3d, 0xd3, 0x5a, 0x6e, 0x66, 0x51, 0x72,
+ 0x9b, 0x4f, 0xa8, 0xd8, 0x26, 0xd6, 0xf6, 0x72, 0xfa, 0x88, 0x3e, 0x11, 0xff,
+ 0xe8, 0x16, 0x20, 0xc1, 0xc0, 0xeb, 0x3e, 0x2c, 0xec, 0x9c, 0xfd, 0x93, 0xc4,
+ 0x5a, 0xde, 0xbb, 0x44,
+ ],
+ [
+ 0x51, 0x2f, 0x56, 0x57, 0x2c, 0xb8, 0xbf, 0x49, 0xc5, 0xb3, 0xc5, 0x52, 0xee,
+ 0x44, 0xed, 0xa9, 0x1d, 0x3f, 0x83, 0x38,
+ ],
+ [
+ 0x2f, 0xf8, 0xbc, 0x67, 0x76, 0x95, 0x0a, 0x39, 0x31, 0x56, 0xf6, 0xa9, 0x82,
+ 0x40, 0x7f, 0xe4, 0xed, 0xad, 0x50, 0x22, 0x60, 0x5c, 0xf8, 0xf1, 0x84, 0x0f,
+ 0xe6, 0x36, 0x7b, 0xa3, 0x06, 0xf6,
+ ],
+ [
+ 0x55, 0x4c, 0xa6, 0x3f, 0xea, 0x2b, 0xea, 0xb8, 0x4c, 0x66, 0x77, 0xce, 0x14,
+ 0x50, 0x63, 0x26, 0x9b, 0xa6, 0xee, 0x54, 0xad, 0x0f, 0x40, 0xd2, 0xd3, 0x56,
+ 0xe3, 0x66, 0x76, 0x85, 0x09, 0xce, 0xb6, 0xdd, 0xe8, 0x21, 0xfa, 0x09, 0xf9,
+ 0x83, 0xfb, 0x30, 0x75, 0x2e, 0x6c, 0x0f, 0x8b, 0xfa,
+ ],
+ [
+ 0x1b, 0xa1, 0xf7, 0x8b, 0x03, 0x01, 0x5c, 0xa7, 0x5c, 0x51, 0x96, 0x38, 0x04,
+ 0x05, 0x72, 0xa2, 0x29, 0xe8, 0x03, 0x1f, 0x1e, 0x92, 0x0a, 0x96, 0x86, 0xd1,
+ 0xa5, 0xe5, 0xbd, 0xaf, 0xb1, 0x61, 0xa0, 0xe0, 0x8d, 0x3a, 0x6e, 0xeb, 0x05,
+ 0x03, 0xba, 0x63, 0xee, 0xce, 0x29, 0xaa, 0x99, 0x43, 0x9f, 0xab, 0xc7, 0xb9,
+ 0x40, 0xde, 0xe5, 0xf9, 0xc0, 0xe6, 0xaa, 0xbd, 0xac, 0x80, 0x8e, 0x87,
+ ]
+ ),
+ test_case!(
+ [
+ 0x08, 0x91, 0x09, 0xbb, 0x22, 0xab, 0x09, 0xc5, 0x09, 0x09, 0xef, 0xe9, 0xcd,
+ 0xf5, 0xa2, 0x61, 0x7d, 0x86, 0x6a, 0x8c, 0x4e, 0xb3, 0x18, 0x40, 0x2a, 0xc8,
+ 0xbf, 0xe2, 0x1a, 0xfa, 0x89, 0x41, 0x5b, 0x2d, 0xe4, 0x59, 0xf0, 0xa3, 0x91,
+ 0xb3, 0x14, 0x6d, 0x2d, 0x0c, 0xc4, 0x96, 0x52, 0xad, 0x14, 0x16, 0x8e, 0x9f,
+ 0xce, 0x20, 0xb4, 0xfa, 0xf5, 0x51, 0xf3, 0x44, 0xbd, 0xaf, 0xf7, 0xbf, 0x28,
+ 0xfa, 0x4a, 0xb8, 0x2c, 0xf3, 0x20, 0x56, 0x02, 0x4a, 0xd1, 0x2a, 0x10, 0xcf,
+ 0x9a, 0x2a, 0x70, 0xcf, 0xeb, 0x29, 0xdf, 0x47, 0x8e, 0x39, 0xaf, 0xe7, 0xb2,
+ 0x93, 0xc3, 0x16, 0x26, 0x4a, 0x26, 0xc2, 0xbc, 0xa7, 0x52, 0x4f, 0xc8, 0x53,
+ 0x76, 0x57, 0x3c, 0x07, 0x05,
+ ],
+ [
+ 0x71, 0x01, 0x3a, 0x3b, 0xe6, 0xfa, 0x3d, 0xcb, 0x65, 0x69, 0xd3, 0x65, 0x77,
+ 0x58, 0xfe, 0x8a, 0xdb, 0x71, 0x63, 0x12,
+ ],
+ [
+ 0x4e, 0x4d, 0x99, 0x18, 0xd4, 0x2a, 0x42, 0x60, 0x0b, 0xa6, 0xfe, 0x3b, 0xd6,
+ 0x9c, 0xaf, 0x5b, 0x34, 0xd6, 0xad, 0xd0, 0xc9, 0x98, 0x92, 0xa1, 0x0e, 0x34,
+ 0x76, 0xc4, 0x04, 0xd1, 0x9d, 0x1d,
+ ],
+ [
+ 0x36, 0xdf, 0x59, 0xb9, 0x54, 0x5e, 0xa2, 0x38, 0x34, 0x0f, 0x51, 0xf6, 0x9b,
+ 0x55, 0x39, 0xf1, 0x22, 0xa9, 0x69, 0x6c, 0x0d, 0x6e, 0xec, 0x18, 0xd3, 0x18,
+ 0x45, 0xe5, 0xd8, 0xcd, 0xeb, 0x50, 0xc9, 0x5d, 0xb7, 0xad, 0x75, 0xcf, 0xc5,
+ 0x5e, 0x48, 0x16, 0x7f, 0xbb, 0x11, 0xda, 0x78, 0x28,
+ ],
+ [
+ 0x8d, 0x05, 0x41, 0xe9, 0x7d, 0xac, 0x4f, 0x6c, 0x4c, 0x5e, 0xe3, 0x0f, 0xe5,
+ 0x63, 0xd4, 0x74, 0x4b, 0x44, 0xc7, 0x83, 0xb4, 0xb1, 0xea, 0xa2, 0xf8, 0x03,
+ 0xe3, 0x1d, 0x13, 0xca, 0x3d, 0xeb, 0xb1, 0x5a, 0x15, 0x4c, 0x41, 0x95, 0xdc,
+ 0xb1, 0xc7, 0x48, 0x46, 0xa5, 0x45, 0x65, 0x83, 0x56, 0x8c, 0x79, 0x31, 0x53,
+ 0x07, 0x36, 0xc5, 0xfc, 0xcc, 0x74, 0xb5, 0x57, 0xbb, 0xbe, 0x8d, 0x01,
+ ]
+ ),
+ test_case!(
+ [
+ 0x16, 0xed, 0xc2, 0xbb, 0xa9, 0xbd, 0x5c, 0x29, 0x77, 0xa5, 0x66, 0x2c, 0x85,
+ 0xb5, 0xa3, 0x36, 0x5b, 0x4a, 0x3a, 0xfd, 0x23, 0xbb, 0x79, 0x1c, 0x59, 0x21,
+ 0x8e, 0x00, 0xba, 0x04, 0xee, 0x43, 0x43, 0x85, 0x0a, 0x22, 0x9f, 0xc5, 0x40,
+ 0xd9, 0xc3, 0x9c, 0x91, 0x4d, 0xc1, 0xdd, 0x1a, 0x92, 0x2f, 0x30, 0xc3, 0x37,
+ 0x64, 0xfe, 0xe7, 0xa4, 0x42, 0x26, 0x7b, 0xa6, 0x2c, 0x80, 0x6b, 0x4d, 0x6a,
+ 0xa0, 0x90, 0xa1, 0xb2, 0x59, 0xac, 0x59, 0x1e, 0xea, 0x83, 0x22, 0x99, 0x4d,
+ 0x07, 0x70, 0x08, 0x0e, 0xc4, 0x3d, 0x95, 0x26, 0x27, 0x43, 0xca, 0x6b, 0x39,
+ 0x5e, 0x94, 0xf7, 0xdc, 0x43, 0x03, 0x9b, 0x90, 0xee, 0xe5, 0xbd, 0xcb, 0x7c,
+ 0x26, 0x81, 0xb9, 0x5b, 0xd6, 0xcc,
+ ],
+ [
+ 0xd8, 0x06, 0xa6, 0xc6, 0x79, 0xf6, 0x6a, 0x53, 0x03, 0xe6, 0xf3, 0x70, 0x07,
+ 0xa7, 0x6a, 0x0a, 0x8f, 0x0c, 0x99, 0x5a,
+ ],
+ [
+ 0xea, 0xc2, 0xf6, 0xd0, 0x0d, 0xdd, 0xac, 0x2c, 0x99, 0x60, 0x4b, 0x7d, 0x54,
+ 0x57, 0xff, 0x9f, 0x71, 0x2b, 0xd3, 0x3b, 0x15, 0x8e, 0x93, 0x67, 0x1b, 0x18,
+ 0xc9, 0x9c, 0xac, 0x01, 0x8b, 0x4d,
+ ],
+ [
+ 0xe0, 0x9d, 0xe5, 0x6d, 0xe3, 0xf5, 0xc5, 0x84, 0x05, 0x51, 0x72, 0x44, 0xe5,
+ 0xdc, 0x2d, 0xb7, 0xe8, 0x66, 0x75, 0x72, 0x49, 0x5d, 0xff, 0xa9, 0x66, 0x7b,
+ 0x61, 0x8b, 0x0d, 0xeb, 0x00, 0x5a, 0x4d, 0x0c, 0xb0, 0xef, 0x8f, 0x8b, 0x78,
+ 0x9e, 0x80, 0xe6, 0x07, 0xd3, 0x65, 0xfc, 0x90, 0x94,
+ ],
+ [
+ 0xd8, 0xa4, 0x2b, 0x57, 0x4f, 0x63, 0xe0, 0xf8, 0x5e, 0xd8, 0x54, 0xca, 0x7d,
+ 0x46, 0x4b, 0x3e, 0xbe, 0xbb, 0x22, 0x63, 0x8d, 0xe8, 0xfb, 0x17, 0xea, 0xbd,
+ 0xfa, 0x3f, 0x9f, 0x15, 0x84, 0x3d, 0x0b, 0xc3, 0x19, 0xc8, 0xbb, 0xbc, 0x7d,
+ 0xb4, 0x9e, 0xe1, 0xa0, 0x7a, 0x62, 0x97, 0xa2, 0xb7, 0x8a, 0x5f, 0x07, 0x6a,
+ 0x59, 0x28, 0xd3, 0xea, 0x23, 0xe7, 0xe9, 0x28, 0xcf, 0xbb, 0x4b, 0x70,
+ ]
+ ),
+ test_case!(
+ [
+ 0xfc, 0xb6, 0x69, 0x62, 0xf1, 0x2c, 0xf4, 0x1e, 0x13, 0x73, 0x36, 0x76, 0x2a,
+ 0xed, 0xab, 0xd3, 0x1c, 0xaa, 0xed, 0x66, 0xa2, 0x04, 0x38, 0x24, 0x44, 0xab,
+ 0xc5, 0x3e, 0x34, 0xbe, 0x9f, 0x52, 0x7b, 0x7a, 0x41, 0x4d, 0xf0, 0x8f, 0xfc,
+ 0x8b, 0x39, 0xb9, 0x5e, 0x2a, 0x2c, 0xb7, 0x10, 0x68, 0xb9, 0xdb, 0x51, 0x72,
+ 0x77, 0x75, 0x40, 0x19, 0xcd, 0x01, 0x4b, 0xc1, 0x2d, 0x3b, 0xff, 0x84, 0x29,
+ 0x39, 0x72, 0x0a, 0x95, 0x33, 0xc5, 0xd9, 0xef, 0xa1, 0xd0, 0x00, 0xb4, 0x97,
+ 0xb9, 0xf2, 0x02, 0xeb, 0xa9, 0xdd, 0x1c, 0xb5, 0x1e, 0xef, 0xdd, 0x9d, 0x4e,
+ 0xed, 0x4d, 0x50, 0xb9, 0x34, 0xb5, 0x5f, 0xdf, 0x92, 0x27, 0x62, 0xc1, 0xb7,
+ 0xeb, 0x1a, 0xa6, 0xa2, 0x7e, 0x0b, 0x35,
+ ],
+ [
+ 0x31, 0x43, 0x5c, 0xca, 0x06, 0xb6, 0xc9, 0xef, 0x74, 0x42, 0x62, 0xf6, 0x0a,
+ 0x20, 0x1b, 0x0e, 0x10, 0xf4, 0xdb, 0x53,
+ ],
+ [
+ 0x56, 0x74, 0xf5, 0x95, 0x39, 0x41, 0x97, 0x58, 0x7a, 0x8f, 0x0f, 0x1e, 0x62,
+ 0x6c, 0xff, 0x2e, 0x96, 0xac, 0xfa, 0x0f, 0x3a, 0x82, 0x31, 0xfc, 0x24, 0x91,
+ 0xde, 0x47, 0x2e, 0x1d, 0x40, 0xeb,
+ ],
+ [
+ 0x31, 0x1b, 0x64, 0x77, 0x0c, 0x4a, 0xff, 0xeb, 0x21, 0x4d, 0x86, 0xbe, 0xbb,
+ 0x87, 0x70, 0x16, 0xd8, 0x6d, 0x41, 0x34, 0xff, 0x45, 0xd5, 0x96, 0xfe, 0x7f,
+ 0xba, 0x49, 0x51, 0x14, 0x16, 0x17, 0x9a, 0x19, 0x7e, 0x25, 0xb6, 0xb9, 0x30,
+ 0x61, 0xa9, 0x5f, 0xa3, 0xe5, 0x48, 0x7a, 0x0f, 0x0e,
+ ],
+ [
+ 0x53, 0xb3, 0x47, 0x7b, 0x80, 0x9a, 0x05, 0x9f, 0xa1, 0x19, 0xe8, 0x32, 0x07,
+ 0x7e, 0xbf, 0x78, 0x6c, 0xbd, 0x04, 0xc2, 0x96, 0x61, 0x66, 0x7a, 0x18, 0xc9,
+ 0x04, 0xd6, 0x77, 0x16, 0x22, 0xf6, 0xb3, 0xd9, 0x0e, 0x3e, 0x15, 0x41, 0x7d,
+ 0x57, 0x1a, 0xa3, 0x7b, 0x85, 0x05, 0xd0, 0x61, 0x99, 0xf9, 0x61, 0xc0, 0xa2,
+ 0x6f, 0xbc, 0x57, 0x67, 0xaf, 0xe5, 0x43, 0xed, 0xe8, 0x9e, 0xaa, 0xb6,
+ ]
+ ),
+ test_case!(
+ [
+ 0xfa, 0x0f, 0xcc, 0xc3, 0xd7, 0x72, 0xd4, 0xba, 0xa5, 0x5c, 0x5b, 0xad, 0x4e,
+ 0xbc, 0x11, 0x04, 0xc6, 0x4c, 0x07, 0x52, 0x0f, 0x59, 0x9f, 0x76, 0x4a, 0xcb,
+ 0xa9, 0x69, 0x8a, 0xb6, 0x5e, 0x8e, 0x47, 0x40, 0x15, 0x99, 0xbe, 0xd2, 0x94,
+ 0x3b, 0xc4, 0x5f, 0x1b, 0xae, 0x38, 0x7b, 0x4e, 0x23, 0x0a, 0xcf, 0x6b, 0x7a,
+ 0xf3, 0xf9, 0x70, 0x2b, 0x73, 0xf6, 0xa1, 0xd3, 0xf8, 0x75, 0xba, 0xf0, 0x6e,
+ 0x08, 0xbc, 0x82, 0xf4, 0x4a, 0xb6, 0x83, 0xcb, 0x2f, 0x2f, 0xb9, 0x43, 0x2a,
+ 0x79, 0x3f, 0x54, 0x60, 0xd5, 0xd2, 0x1a, 0x8a, 0x31, 0x26, 0x4e, 0x90, 0x63,
+ 0x43, 0xd5, 0x9a, 0xdb, 0x0c, 0x10, 0x47, 0x08, 0x4f, 0x43, 0xff, 0x9c, 0x69,
+ 0x27, 0xd7, 0xf0, 0x0f, 0xea, 0x9d, 0xb1, 0x0d,
+ ],
+ [
+ 0xbf, 0x92, 0x70, 0x6a, 0x3e, 0x60, 0x3c, 0x03, 0x43, 0xca, 0xff, 0x84, 0x90,
+ 0xc5, 0x30, 0xe8, 0xe3, 0x69, 0x18, 0x4a,
+ ],
+ [
+ 0xfd, 0x1b, 0x42, 0x3b, 0xc8, 0x52, 0xe8, 0xe1, 0xc1, 0x0e, 0x8b, 0xff, 0xf5,
+ 0x1b, 0x41, 0xd1, 0x63, 0xcf, 0x87, 0x75, 0x0b, 0xd3, 0xa3, 0xba, 0xd1, 0x1b,
+ 0xd9, 0x82, 0xa3, 0xeb, 0x94, 0xab,
+ ],
+ [
+ 0xbb, 0x0d, 0x99, 0x79, 0xe1, 0x4a, 0x94, 0x6d, 0x43, 0x0b, 0x9b, 0xe9, 0x86,
+ 0x0f, 0xc7, 0xbf, 0xc5, 0x55, 0x0c, 0xb0, 0x7f, 0x53, 0x44, 0xed, 0x73, 0x43,
+ 0x14, 0xc1, 0xf1, 0x27, 0xe5, 0xee, 0x7d, 0x47, 0xec, 0xd3, 0x17, 0xe7, 0x59,
+ 0xc5, 0xc2, 0xb4, 0x24, 0x89, 0x42, 0x44, 0x1a, 0x70,
+ ],
+ [
+ 0x92, 0x6d, 0xe1, 0xfb, 0x19, 0xbd, 0x1f, 0x06, 0xda, 0xfd, 0x0e, 0x36, 0xc0,
+ 0x92, 0xa1, 0x9c, 0xb9, 0xf2, 0xa3, 0x24, 0x0a, 0xcc, 0xc4, 0x17, 0x50, 0x87,
+ 0xba, 0xa8, 0xcc, 0xaa, 0xef, 0x87, 0x7b, 0x32, 0xa6, 0x95, 0x36, 0x7d, 0x37,
+ 0xa8, 0xef, 0x66, 0xc4, 0x58, 0xb9, 0xd0, 0xaf, 0x4c, 0xa3, 0xf4, 0x9a, 0x1e,
+ 0xe0, 0x4f, 0xd5, 0x78, 0x90, 0xe1, 0xce, 0xe0, 0x45, 0x39, 0xb7, 0x57,
+ ]
+ ),
+ test_case!(
+ [
+ 0xda, 0x26, 0x0b, 0x04, 0x34, 0x5e, 0x9a, 0xb4, 0xd3, 0x08, 0x01, 0xea, 0xd6,
+ 0x5f, 0xd2, 0x57, 0x49, 0xfc, 0x5b, 0x8e, 0xbc, 0x41, 0xab, 0x5c, 0x19, 0xc4,
+ 0x9f, 0xc5, 0x6c, 0x3d, 0xd1, 0xec, 0x97, 0xaf, 0xc6, 0x89, 0x88, 0xc4, 0xc4,
+ 0x5e, 0x5c, 0x6e, 0xb3, 0xa3, 0xed, 0x1f, 0xe1, 0x4b, 0x19, 0x76, 0xc3, 0x92,
+ 0xbc, 0x25, 0x15, 0x91, 0x8c, 0xb9, 0x59, 0x9a, 0x3b, 0xb3, 0x1b, 0xee, 0x22,
+ 0x8a, 0x0f, 0xe3, 0x55, 0x9a, 0xe7, 0xac, 0xbb, 0x00, 0x69, 0xb0, 0x04, 0xba,
+ 0xa0, 0xc8, 0xea, 0x64, 0x4f, 0x87, 0x9f, 0x74, 0x07, 0x89, 0xa0, 0x5f, 0x34,
+ 0xda, 0xec, 0x74, 0x59, 0x2a, 0x8f, 0xde, 0xcc, 0x91, 0x14, 0x77, 0x86, 0x6f,
+ 0x10, 0x77, 0xb6, 0x98, 0xc6, 0xaa, 0xcc, 0xd1, 0x73,
+ ],
+ [
+ 0x02, 0x4a, 0xcc, 0x12, 0x4d, 0x8d, 0x62, 0x46, 0xa5, 0x3f, 0xae, 0x33, 0xb1,
+ 0x0c, 0x2f, 0x2c, 0x71, 0xa1, 0xc1, 0x56,
+ ],
+ [
+ 0xe3, 0x87, 0xc8, 0xb5, 0x95, 0xa2, 0x53, 0x83, 0xf8, 0x24, 0xd7, 0xe2, 0x66,
+ 0x44, 0xee, 0x0e, 0x2a, 0x2f, 0x08, 0xd5, 0xfd, 0x0d, 0x98, 0x37, 0x49, 0x01,
+ 0x48, 0xb2, 0xd7, 0xcd, 0xed, 0xb7,
+ ],
+ [
+ 0xd3, 0x75, 0x50, 0x6d, 0x13, 0x3a, 0x0b, 0xe2, 0x56, 0xc5, 0xea, 0xdd, 0xff,
+ 0x3f, 0x01, 0x94, 0xbf, 0x3f, 0x35, 0xd1, 0x10, 0x23, 0x7f, 0xce, 0x7b, 0x92,
+ 0xc8, 0x65, 0xd6, 0x17, 0x05, 0x20, 0x09, 0x75, 0x38, 0x6d, 0x3c, 0xbe, 0xf7,
+ 0x63, 0x46, 0xf5, 0x9d, 0xe0, 0x75, 0x0b, 0x74, 0x66,
+ ],
+ [
+ 0x29, 0xf1, 0xff, 0x45, 0x06, 0x5d, 0x39, 0x05, 0x13, 0x49, 0x0e, 0xd9, 0xaf,
+ 0x45, 0x75, 0x94, 0xc0, 0x97, 0xb2, 0xd2, 0x26, 0x7c, 0xd1, 0x99, 0xdc, 0x72,
+ 0xfc, 0x85, 0xd5, 0x81, 0x13, 0x8e, 0x2b, 0xd2, 0xff, 0x61, 0xae, 0x6c, 0x31,
+ 0x73, 0xe2, 0x88, 0xe2, 0xea, 0xa3, 0xb8, 0x74, 0xfe, 0x24, 0x0f, 0x88, 0x07,
+ 0x63, 0x2c, 0x8c, 0xb3, 0x87, 0xc9, 0xda, 0x24, 0x95, 0x9a, 0x1b, 0xf0,
+ ]
+ ),
+ test_case!(
+ [
+ 0xfa, 0x16, 0x60, 0x22, 0x9c, 0x82, 0x54, 0xa5, 0x3d, 0x55, 0x53, 0x30, 0xbf,
+ 0xfa, 0x34, 0x6a, 0xd0, 0xc8, 0xf3, 0xa7, 0xb6, 0xeb, 0x91, 0x28, 0x31, 0xbe,
+ 0x80, 0x35, 0x7c, 0x14, 0xa2, 0x1d, 0x49, 0x7c, 0xe2, 0x19, 0xbd, 0xd4, 0xef,
+ 0x10, 0xdc, 0xf1, 0xff, 0x73, 0x2f, 0xe8, 0x92, 0x55, 0xbf, 0xca, 0x74, 0x65,
+ 0xc4, 0xb5, 0xa1, 0x6b, 0x0e, 0xe1, 0xc9, 0x84, 0x02, 0xad, 0x7c, 0x5f, 0xd9,
+ 0xa7, 0x80, 0x2b, 0x86, 0x25, 0x15, 0xb1, 0xd9, 0xc2, 0xed, 0x2b, 0x03, 0xae,
+ 0x05, 0x36, 0x87, 0x1b, 0x2a, 0x5f, 0x89, 0x0c, 0x01, 0x1b, 0xc4, 0x69, 0x1a,
+ 0xb5, 0xd0, 0x46, 0x39, 0xed, 0x1c, 0xfd, 0x80, 0x3d, 0xbe, 0x66, 0xcc, 0x2b,
+ 0x40, 0xc5, 0x5e, 0x28, 0x1d, 0xc0, 0xc3, 0xec, 0x5d, 0x26,
+ ],
+ [
+ 0x71, 0x22, 0x5e, 0x1d, 0x93, 0x49, 0x48, 0xd6, 0x81, 0xba, 0x85, 0xae, 0x53,
+ 0xf3, 0x02, 0xa5, 0xf7, 0x53, 0xf8, 0xe8,
+ ],
+ [
+ 0xdc, 0xe2, 0x87, 0x83, 0x6f, 0x56, 0x6a, 0x4b, 0xc1, 0xd5, 0xdc, 0x28, 0xd8,
+ 0x5d, 0xdb, 0x51, 0xd3, 0x18, 0x5f, 0xb4, 0x6b, 0x79, 0x54, 0xe6, 0xad, 0xa4,
+ 0xcc, 0xae, 0xd7, 0x10, 0xf7, 0xfc,
+ ],
+ [
+ 0x25, 0xb8, 0xf6, 0xec, 0xba, 0x39, 0x8c, 0xd2, 0xe6, 0x24, 0xb6, 0xc9, 0x1c,
+ 0x68, 0x4b, 0x17, 0xfe, 0xd3, 0x8e, 0x9e, 0x88, 0xc0, 0xbf, 0x03, 0x5b, 0xec,
+ 0x3d, 0x63, 0x80, 0xf5, 0xee, 0x9b, 0x40, 0x92, 0x14, 0x62, 0xd6, 0x28, 0x45,
+ 0x49, 0x70, 0x07, 0xff, 0x8b, 0x66, 0x99, 0x2d, 0xb8,
+ ],
+ [
+ 0xf2, 0xf3, 0x77, 0xc3, 0x88, 0x05, 0xd3, 0x8d, 0x0f, 0x45, 0x10, 0x2c, 0xd8,
+ 0x3f, 0x53, 0xea, 0x4a, 0x2a, 0x3e, 0x2b, 0xf6, 0x33, 0xd9, 0x6e, 0x14, 0xe6,
+ 0xd3, 0x7d, 0x86, 0x8b, 0x88, 0xb4, 0x1a, 0x3e, 0xec, 0xa7, 0x91, 0x17, 0x78,
+ 0x0e, 0x70, 0xe8, 0x65, 0x5f, 0x66, 0x82, 0xee, 0x20, 0xdd, 0x0e, 0xb0, 0x17,
+ 0x43, 0x0c, 0x74, 0x9b, 0x72, 0x39, 0x9f, 0xca, 0x51, 0x23, 0xa0, 0x44,
+ ]
+ ),
+ test_case!(
+ [
+ 0xe9, 0x14, 0xcd, 0x1d, 0xaa, 0xa3, 0xaa, 0xee, 0x42, 0x9e, 0xc3, 0x99, 0xf6,
+ 0x7f, 0x46, 0xa0, 0x69, 0x3c, 0x36, 0x3f, 0x86, 0xe4, 0xaa, 0xbb, 0xd1, 0x46,
+ 0x33, 0xf9, 0x8a, 0x6a, 0xb3, 0x63, 0xd1, 0x2b, 0xc6, 0xdd, 0x18, 0x46, 0x64,
+ 0xa9, 0x53, 0x53, 0xf7, 0x3c, 0xf7, 0x71, 0x79, 0x1d, 0x53, 0x58, 0x69, 0x5d,
+ 0x01, 0x49, 0xfc, 0x5f, 0x04, 0x84, 0xd4, 0xb5, 0xea, 0xcb, 0x84, 0xd2, 0x1f,
+ 0x55, 0x32, 0xf8, 0xfe, 0xed, 0xc9, 0xac, 0x0d, 0x78, 0x35, 0x5e, 0xca, 0x03,
+ 0x57, 0x25, 0x26, 0x5d, 0x7d, 0xfa, 0x39, 0x48, 0xed, 0xde, 0xc4, 0x97, 0x2b,
+ 0x78, 0xb4, 0x1e, 0x50, 0xee, 0x57, 0xc7, 0x4e, 0xc2, 0xcc, 0x9a, 0xe7, 0x8e,
+ 0x1b, 0x3d, 0x00, 0x46, 0x38, 0x27, 0xfb, 0x06, 0x27, 0x2f, 0xae,
+ ],
+ [
+ 0xee, 0x1a, 0x6d, 0xe5, 0x66, 0xa8, 0x5a, 0xc6, 0x94, 0x6c, 0x87, 0xa7, 0x0d,
+ 0xab, 0x7d, 0x4a, 0xab, 0xfd, 0xde, 0xf9,
+ ],
+ [
+ 0x41, 0xa3, 0x87, 0xff, 0x2e, 0x53, 0xd4, 0x03, 0xaf, 0x0b, 0x00, 0xe5, 0x6d,
+ 0x09, 0x5b, 0x84, 0xa4, 0x99, 0x05, 0x6a, 0xc3, 0x60, 0x2b, 0xea, 0x0d, 0x33,
+ 0x39, 0x2c, 0x15, 0x78, 0xd6, 0x15,
+ ],
+ [
+ 0xe3, 0x86, 0x61, 0xaa, 0xf6, 0x1d, 0x8e, 0xd7, 0x95, 0x53, 0x30, 0x04, 0xcb,
+ 0xe0, 0x5e, 0x27, 0xb0, 0x26, 0x14, 0xeb, 0xa4, 0xfb, 0x25, 0xda, 0x1f, 0x25,
+ 0xb7, 0xab, 0x6e, 0x00, 0xcc, 0x8b, 0xb3, 0x7d, 0x31, 0xd8, 0xb8, 0x20, 0x7a,
+ 0x66, 0x7e, 0xb1, 0x0d, 0x49, 0x9c, 0x42, 0xfe, 0x6c,
+ ],
+ [
+ 0x8a, 0xb0, 0x44, 0xe2, 0x02, 0xdb, 0x19, 0x9e, 0x3b, 0xe9, 0x54, 0xa1, 0x75,
+ 0x8d, 0xdc, 0xda, 0x9c, 0xa3, 0x79, 0x58, 0x1b, 0xfb, 0xa8, 0xbc, 0x8b, 0x71,
+ 0xad, 0x54, 0x7c, 0x48, 0xc6, 0x82, 0xfb, 0xf1, 0x7e, 0xb9, 0x10, 0xe7, 0x33,
+ 0x01, 0x2c, 0xa6, 0xf6, 0x59, 0x93, 0xe4, 0x20, 0x18, 0x27, 0xc3, 0xfb, 0x7e,
+ 0x10, 0xd8, 0x26, 0xab, 0x64, 0xe2, 0xa3, 0xc6, 0x83, 0x81, 0xb1, 0xe3,
+ ]
+ ),
+ test_case!(
+ [
+ 0xcd, 0x38, 0x14, 0x08, 0xbb, 0x30, 0x55, 0xb1, 0x96, 0xb6, 0xe1, 0xd3, 0x3a,
+ 0xd6, 0x6c, 0xb0, 0x9f, 0x59, 0xe2, 0xef, 0xd8, 0x37, 0x65, 0x29, 0x57, 0x59,
+ 0xb3, 0xae, 0xbe, 0x51, 0x1c, 0xc9, 0xe2, 0x6e, 0x1f, 0x7d, 0x91, 0x88, 0xdf,
+ 0x71, 0xff, 0x1e, 0xd2, 0x0a, 0x83, 0xfe, 0xa4, 0xcd, 0xf6, 0xbb, 0x78, 0x62,
+ 0xaf, 0xd5, 0x4c, 0x4e, 0xa4, 0x7b, 0x9d, 0xaa, 0x71, 0x53, 0xba, 0xbe, 0x9f,
+ 0xb9, 0x3b, 0xe3, 0x7d, 0x0b, 0xe9, 0xa9, 0x6e, 0xbe, 0x3b, 0x75, 0xbf, 0x30,
+ 0x0f, 0x4c, 0x38, 0x59, 0xc2, 0x50, 0xcb, 0x0d, 0xc8, 0xb8, 0xf7, 0x68, 0xcb,
+ 0xe1, 0x7f, 0x72, 0x36, 0xa7, 0xa6, 0x8f, 0x99, 0x41, 0x7f, 0x09, 0x69, 0xc5,
+ 0x53, 0xf7, 0x97, 0x46, 0xf4, 0x28, 0x65, 0x82, 0x51, 0x1d, 0x77, 0x45,
+ ],
+ [
+ 0xce, 0x77, 0xa7, 0x1c, 0xce, 0xbf, 0x34, 0x15, 0xeb, 0xfc, 0x13, 0x66, 0xad,
+ 0x27, 0xad, 0x6b, 0x25, 0x43, 0xc9, 0xfc,
+ ],
+ [
+ 0x8d, 0xdc, 0x55, 0xbd, 0x0a, 0xc3, 0xf3, 0xe8, 0xf6, 0x45, 0x9a, 0x18, 0x16,
+ 0xf7, 0xcb, 0x5c, 0x92, 0x3b, 0x8d, 0xfa, 0x63, 0x12, 0xb0, 0xf3, 0x0f, 0x33,
+ 0x72, 0xe1, 0x0f, 0x20, 0x17, 0x2a,
+ ],
+ [
+ 0x7d, 0x9a, 0x51, 0xf1, 0xac, 0xdb, 0x98, 0xc9, 0x7c, 0xe1, 0x2f, 0xa7, 0x62,
+ 0x9b, 0x11, 0x17, 0x4a, 0x8d, 0xdb, 0xd3, 0x25, 0xd1, 0x3c, 0x65, 0x59, 0x12,
+ 0x0e, 0x60, 0x7d, 0xe6, 0xed, 0x40, 0xeb, 0x19, 0x99, 0x1f, 0xfc, 0xac, 0x43,
+ 0xc5, 0x18, 0x1a, 0x23, 0x9d, 0x9d, 0x05, 0x77, 0xee,
+ ],
+ [
+ 0x7b, 0xc8, 0xe7, 0x3f, 0xe4, 0xca, 0x5f, 0x74, 0x3a, 0x78, 0xed, 0xde, 0xc5,
+ 0xa7, 0x76, 0xdd, 0x48, 0x1b, 0x06, 0x3e, 0x1c, 0x95, 0x98, 0x6c, 0x7f, 0xb9,
+ 0x79, 0xba, 0x74, 0x43, 0xa2, 0xa3, 0x73, 0x22, 0x42, 0x94, 0xb4, 0xf3, 0xef,
+ 0xb5, 0xb9, 0x93, 0x81, 0x5b, 0xa3, 0x44, 0xa7, 0xf6, 0x3e, 0x73, 0xa5, 0x67,
+ 0x8e, 0xa8, 0xa0, 0x40, 0xe2, 0xef, 0xbf, 0x4a, 0x0d, 0x5e, 0x29, 0xdc,
+ ]
+ ),
+ test_case!(
+ [
+ 0xb1, 0x65, 0x9d, 0xe2, 0xe3, 0x67, 0x82, 0xf3, 0x8a, 0x22, 0xc5, 0x80, 0x54,
+ 0x2c, 0xc9, 0xc9, 0xc9, 0xaf, 0x93, 0x18, 0xcd, 0xe8, 0x21, 0x1a, 0x49, 0xa7,
+ 0xbc, 0x07, 0x7c, 0xba, 0xa3, 0x5b, 0x44, 0x69, 0x93, 0xe7, 0x17, 0x41, 0xad,
+ 0xd6, 0x56, 0xc5, 0x96, 0xf9, 0x51, 0xc3, 0x7e, 0x3c, 0x52, 0xdc, 0xe2, 0x86,
+ 0x46, 0xa6, 0x8e, 0x14, 0x33, 0xf1, 0x46, 0xc1, 0x4f, 0xda, 0x7e, 0x32, 0x75,
+ 0xca, 0xb3, 0x54, 0x81, 0x74, 0x39, 0x42, 0x23, 0xef, 0x84, 0x0b, 0x27, 0x3f,
+ 0xf7, 0xf4, 0x34, 0x06, 0x91, 0x88, 0xcd, 0x00, 0x55, 0xdb, 0x22, 0xbe, 0xdb,
+ 0x97, 0xa5, 0x71, 0x99, 0x21, 0xaa, 0x14, 0x47, 0x99, 0xe4, 0x7c, 0xbc, 0x3a,
+ 0xb3, 0x70, 0xc0, 0x1d, 0x70, 0xbf, 0xfc, 0xc5, 0x37, 0xc4, 0xdd, 0x04, 0xcc,
+ ],
+ [
+ 0x74, 0x61, 0x00, 0x22, 0x50, 0x99, 0x43, 0x5c, 0x77, 0xc2, 0x05, 0x19, 0xd1,
+ 0x8c, 0x87, 0x5e, 0x7d, 0x8d, 0x3d, 0xb5,
+ ],
+ [
+ 0x1c, 0xd5, 0xa3, 0x90, 0x43, 0x39, 0x4f, 0x0a, 0x1d, 0xa4, 0x01, 0x79, 0xde,
+ 0x1b, 0x82, 0xfa, 0xbf, 0x2a, 0xcc, 0xa3, 0x47, 0x8e, 0xb3, 0x76, 0xfc, 0x5f,
+ 0x68, 0xdf, 0x07, 0x37, 0x32, 0xcd,
+ ],
+ [
+ 0x5e, 0x73, 0x8c, 0x16, 0xf6, 0x0b, 0x6c, 0xa3, 0xc4, 0x50, 0xc3, 0x56, 0xba,
+ 0x1e, 0xc0, 0x38, 0xe0, 0xb6, 0x7d, 0x80, 0x10, 0x48, 0xca, 0xbe, 0x0e, 0x04,
+ 0x1c, 0xc0, 0x45, 0x3d, 0xfd, 0xc1, 0xaf, 0xda, 0x12, 0xc8, 0x92, 0x41, 0x69,
+ 0x20, 0x0d, 0xfb, 0x92, 0x86, 0x52, 0xca, 0x42, 0xb9,
+ ],
+ [
+ 0xd1, 0x67, 0x13, 0x0d, 0x9c, 0x66, 0x7e, 0xda, 0xbd, 0xed, 0x15, 0xd2, 0x51,
+ 0x30, 0xc4, 0x1b, 0xea, 0xaf, 0x45, 0x99, 0x60, 0x6a, 0x5d, 0xbb, 0x3b, 0x1d,
+ 0xc2, 0x96, 0xbe, 0xaf, 0x03, 0x77, 0xc1, 0x4e, 0xb2, 0xb0, 0x6e, 0x76, 0xd6,
+ 0x38, 0xf2, 0x61, 0xa4, 0x53, 0x72, 0x3b, 0xe2, 0x94, 0x54, 0x11, 0x96, 0xe2,
+ 0x04, 0x7d, 0x82, 0x33, 0x2a, 0x83, 0xeb, 0xaf, 0x7a, 0x31, 0x93, 0xc6,
+ ]
+ ),
+ test_case!(
+ [
+ 0x28, 0xf9, 0x3c, 0x84, 0x76, 0x04, 0x5a, 0x55, 0x3b, 0x78, 0x4d, 0x86, 0x34,
+ 0xc4, 0x8a, 0x11, 0xc9, 0x7b, 0xcf, 0x1a, 0x01, 0x02, 0xb5, 0x4b, 0x27, 0x92,
+ 0x5d, 0xa7, 0x72, 0xcc, 0xdc, 0x61, 0xd3, 0x09, 0xc8, 0x48, 0x80, 0x09, 0xd3,
+ 0x8b, 0x3f, 0xf5, 0x25, 0x86, 0x5e, 0x53, 0x88, 0xce, 0x8c, 0x1d, 0x4b, 0x89,
+ 0x92, 0x23, 0xed, 0x7d, 0x6c, 0x84, 0x68, 0xb0, 0x71, 0x59, 0x8e, 0xd8, 0x4d,
+ 0x11, 0xad, 0x2a, 0xe4, 0x5b, 0x96, 0x26, 0xf5, 0xbc, 0x07, 0x3c, 0xde, 0x43,
+ 0x56, 0x5a, 0x70, 0x54, 0x27, 0x66, 0x32, 0xf7, 0x3a, 0x92, 0x71, 0x57, 0xc0,
+ 0xfe, 0xf1, 0x8b, 0x2b, 0x83, 0x13, 0x5e, 0xf6, 0xcc, 0x8d, 0x5d, 0xb4, 0xbf,
+ 0xfc, 0x9a, 0xf3, 0xa2, 0x7d, 0xb1, 0xe6, 0x29, 0x93, 0x96, 0xde, 0xf5, 0x2f,
+ 0xb6,
+ ],
+ [
+ 0xc6, 0xf4, 0x05, 0xed, 0x7e, 0x74, 0xc4, 0x64, 0xbb, 0x94, 0x69, 0x3f, 0x76,
+ 0xb5, 0x5e, 0x06, 0x9b, 0x8a, 0x29, 0xb8,
+ ],
+ [
+ 0x3d, 0x06, 0x17, 0x59, 0x7b, 0xc0, 0x6f, 0x36, 0x1e, 0x4a, 0xad, 0x93, 0x45,
+ 0xcb, 0x2c, 0x42, 0xd8, 0xfb, 0x68, 0x5e, 0x50, 0xb3, 0x1f, 0x7d, 0xd3, 0x4f,
+ 0xf8, 0x10, 0x6b, 0x64, 0xf7, 0x08,
+ ],
+ [
+ 0xa2, 0x23, 0x4f, 0x6c, 0xee, 0xd3, 0xbe, 0x45, 0x56, 0x5c, 0x8c, 0x9e, 0x8e,
+ 0x66, 0x23, 0xca, 0x60, 0x7b, 0xa4, 0xc9, 0xb1, 0x96, 0x82, 0x45, 0x68, 0x87,
+ 0x9c, 0x8e, 0x44, 0x65, 0xa0, 0x35, 0x8e, 0xcf, 0x98, 0x3a, 0x21, 0xdd, 0xb4,
+ 0x20, 0x93, 0xc5, 0x80, 0xc3, 0x7c, 0xaa, 0x56, 0x26,
+ ],
+ [
+ 0xc1, 0x68, 0xe6, 0x44, 0x84, 0xcf, 0x77, 0xee, 0xea, 0xa2, 0xbb, 0xdb, 0xcb,
+ 0xa7, 0xed, 0xdf, 0xfe, 0x57, 0x3f, 0x23, 0x40, 0x4c, 0x0c, 0x2a, 0x27, 0x7e,
+ 0x64, 0x5e, 0x06, 0xe0, 0xb7, 0xd2, 0xba, 0x1a, 0xbd, 0xa3, 0x82, 0xb9, 0xc5,
+ 0xc7, 0x36, 0x43, 0xbc, 0x67, 0xa5, 0xfc, 0x33, 0x80, 0xba, 0x7b, 0x06, 0x7e,
+ 0x8c, 0xa5, 0xa6, 0x5c, 0xe3, 0x72, 0x0b, 0x41, 0xe5, 0x9d, 0xc8, 0xef,
+ ]
+ ),
+ test_case!(
+ [
+ 0x3b, 0xd5, 0x8d, 0x03, 0x6b, 0x3f, 0x48, 0x08, 0x9c, 0x94, 0xa3, 0x41, 0xbb,
+ 0x74, 0x0e, 0xc5, 0x9b, 0xc1, 0x02, 0x53, 0xb2, 0xcd, 0xbe, 0xee, 0x77, 0x7d,
+ 0x76, 0x59, 0xd7, 0x2f, 0x94, 0xb0, 0x91, 0x4f, 0x69, 0xeb, 0x68, 0xb4, 0xd4,
+ 0x34, 0x31, 0x70, 0xc9, 0x85, 0xf2, 0x7e, 0x7e, 0x82, 0x0d, 0x1b, 0x0f, 0xcf,
+ 0xaa, 0xf5, 0xce, 0xf8, 0x67, 0xae, 0x19, 0x5a, 0xc1, 0xcc, 0x8a, 0xbf, 0x93,
+ 0xa8, 0xf0, 0x58, 0x4a, 0x33, 0xe8, 0x91, 0x39, 0xe2, 0xf3, 0x1a, 0x78, 0xae,
+ 0xb8, 0x0a, 0xb1, 0x14, 0x90, 0xe8, 0xe7, 0xf4, 0x97, 0x15, 0x50, 0x84, 0x73,
+ 0x08, 0xd9, 0x79, 0x76, 0x69, 0x90, 0x9c, 0xe2, 0x62, 0xa6, 0x3b, 0x12, 0x8b,
+ 0x78, 0xb3, 0x1c, 0xa4, 0x5b, 0x3c, 0xe9, 0x29, 0xda, 0xaf, 0xcd, 0x85, 0x0d,
+ 0xd6, 0x20,
+ ],
+ [
+ 0x21, 0xc1, 0xe1, 0x5d, 0x4b, 0x96, 0x24, 0xd7, 0xa8, 0xb4, 0x90, 0x78, 0x97,
+ 0xe2, 0xcf, 0xd1, 0xc8, 0xba, 0x2a, 0x84,
+ ],
+ [
+ 0x5d, 0xa5, 0xd6, 0x23, 0x84, 0x42, 0x07, 0x6b, 0x9f, 0xd7, 0x8f, 0x5b, 0xd3,
+ 0xd2, 0xf3, 0xc4, 0x7f, 0xee, 0x87, 0x14, 0xa4, 0xcb, 0x1c, 0x4d, 0xbe, 0xfd,
+ 0xfb, 0x8f, 0xfd, 0x51, 0x89, 0x73,
+ ],
+ [
+ 0x85, 0x31, 0xc9, 0x87, 0x03, 0x7d, 0x56, 0xc7, 0x2d, 0x64, 0x2c, 0xb9, 0xb9,
+ 0xa2, 0x1a, 0x20, 0xa8, 0x52, 0xf8, 0x67, 0x0b, 0xad, 0x5f, 0x62, 0xa2, 0xec,
+ 0x6c, 0xa7, 0xc3, 0xdb, 0x01, 0xd1, 0xdd, 0xdb, 0x8f, 0xb2, 0x1b, 0x41, 0xf3,
+ 0xf8, 0xad, 0x19, 0xba, 0x0f, 0x09, 0xc6, 0x58, 0x2f,
+ ],
+ [
+ 0x04, 0x43, 0x26, 0x1b, 0x38, 0x7e, 0x1f, 0x9c, 0x07, 0x4a, 0xf0, 0x98, 0xd2,
+ 0xcf, 0x2a, 0x60, 0x53, 0x5c, 0x62, 0x14, 0x7b, 0xb7, 0x3d, 0x35, 0x05, 0xbf,
+ 0x7d, 0xc0, 0xfc, 0x3f, 0xb0, 0xac, 0xb9, 0x6b, 0xe3, 0xa5, 0x6e, 0x8b, 0xff,
+ 0xa2, 0x6a, 0xa2, 0xcf, 0x80, 0x14, 0x09, 0x92, 0x31, 0x23, 0x3c, 0x5c, 0x9d,
+ 0xb5, 0x05, 0xfe, 0x52, 0xa8, 0x6b, 0x8d, 0x29, 0x4d, 0x7e, 0xcd, 0x55,
+ ]
+ ),
+ test_case!(
+ [
+ 0xaf, 0x98, 0x3e, 0x36, 0x71, 0x5f, 0xe4, 0x10, 0xc6, 0x89, 0x6b, 0xdf, 0xb6,
+ 0xff, 0xe2, 0xc2, 0x64, 0xaf, 0xd7, 0xa3, 0x4a, 0x4e, 0x0d, 0x4e, 0x31, 0xf5,
+ 0xb5, 0xc2, 0x7d, 0x8b, 0x6c, 0xc8, 0xfb, 0xf7, 0x2f, 0xbb, 0xaa, 0x4d, 0x95,
+ 0x0f, 0x78, 0x8e, 0x92, 0x84, 0x0f, 0x30, 0x28, 0x7b, 0xdc, 0x77, 0x66, 0x93,
+ 0xbc, 0x9c, 0x66, 0x7b, 0x1e, 0x49, 0x42, 0xd8, 0x64, 0x8f, 0x2d, 0x14, 0x43,
+ 0xec, 0x37, 0x2a, 0x65, 0x80, 0x93, 0xbe, 0x70, 0xf4, 0x36, 0x2d, 0x8d, 0xbc,
+ 0x6a, 0x4b, 0xe0, 0x5a, 0x5b, 0x66, 0xe2, 0x93, 0xfe, 0xf8, 0xeb, 0x07, 0xfd,
+ 0x0d, 0x5f, 0x15, 0x03, 0xe1, 0x5d, 0x9e, 0xa8, 0x23, 0x60, 0xf5, 0x8b, 0xfc,
+ 0xbf, 0x7c, 0xef, 0xbc, 0xbb, 0x30, 0x63, 0x83, 0xdf, 0xec, 0x7f, 0x51, 0x0f,
+ 0xd4, 0xf8, 0x0a,
+ ],
+ [
+ 0xdc, 0x75, 0xbf, 0xa6, 0xc2, 0x0c, 0xfe, 0x23, 0x29, 0xd5, 0x20, 0x80, 0x60,
+ 0x93, 0x62, 0x31, 0xbe, 0x8b, 0x61, 0x90,
+ ],
+ [
+ 0x37, 0xc6, 0xb5, 0x09, 0x61, 0x29, 0xbb, 0xa4, 0x38, 0xba, 0xff, 0x13, 0xdb,
+ 0xe5, 0xdd, 0x5c, 0x08, 0x64, 0xcc, 0x73, 0x5d, 0xee, 0xdc, 0x2d, 0x72, 0xa4,
+ 0x49, 0x63, 0x77, 0x74, 0xbd, 0x05,
+ ],
+ [
+ 0x76, 0xfe, 0x98, 0xcd, 0xec, 0x95, 0xb3, 0x2f, 0x11, 0x1c, 0x73, 0xa1, 0x9a,
+ 0x99, 0x62, 0xf3, 0x76, 0x4d, 0x56, 0xc1, 0xc1, 0xee, 0x9e, 0xc0, 0x23, 0xf1,
+ 0xbb, 0xac, 0x1b, 0xbb, 0x9c, 0x84, 0xc9, 0x6a, 0x81, 0xb7, 0xfc, 0xd4, 0x99,
+ 0xe4, 0xa2, 0xb8, 0xa8, 0x4f, 0x88, 0xc9, 0x9b, 0x90,
+ ],
+ [
+ 0x79, 0x9b, 0x61, 0x00, 0x7f, 0x80, 0x9a, 0xa5, 0x75, 0x9f, 0x24, 0x8d, 0x65,
+ 0x72, 0x47, 0xa2, 0xb5, 0x8d, 0xb2, 0x4c, 0x65, 0x78, 0x12, 0xb6, 0x75, 0x94,
+ 0x29, 0xd1, 0x1f, 0x35, 0xfb, 0x01, 0x33, 0x0f, 0xca, 0x51, 0xb8, 0xc1, 0x86,
+ 0x83, 0xfe, 0xb9, 0xf7, 0x58, 0x41, 0x75, 0x54, 0x9e, 0x48, 0x2d, 0xe9, 0xbd,
+ 0xac, 0x2e, 0xce, 0xc7, 0x11, 0x2c, 0xbc, 0x06, 0xe8, 0xa9, 0x0e, 0xe9,
+ ]
+ ),
+ test_case!(
+ [
+ 0x9c, 0x3f, 0x25, 0x14, 0x00, 0x78, 0xfa, 0x99, 0x6b, 0x73, 0xe3, 0x19, 0x49,
+ 0xb9, 0x17, 0x98, 0x75, 0xae, 0xb0, 0x06, 0xba, 0x1e, 0xdc, 0xdb, 0x44, 0x25,
+ 0x7d, 0xe9, 0x54, 0xdb, 0x19, 0x5a, 0xad, 0x39, 0xbd, 0x9e, 0x55, 0xc0, 0x64,
+ 0xe0, 0x9f, 0x1e, 0xf0, 0x68, 0xeb, 0x85, 0xf4, 0xdc, 0x45, 0x35, 0x62, 0x1e,
+ 0xb7, 0x46, 0x20, 0xa4, 0xdb, 0x0e, 0x80, 0xb8, 0x9a, 0xec, 0xa9, 0xa7, 0x10,
+ 0xa1, 0x1f, 0x3f, 0x6b, 0x94, 0xd4, 0x13, 0x63, 0x63, 0xd6, 0x9f, 0xdf, 0x51,
+ 0x7d, 0x69, 0x7a, 0xfa, 0x8a, 0x39, 0x16, 0xbc, 0xad, 0x3a, 0x60, 0x5f, 0xad,
+ 0x59, 0xa4, 0xb5, 0x98, 0x77, 0x71, 0xbc, 0xff, 0x89, 0xc6, 0x31, 0xf5, 0xd3,
+ 0x00, 0x56, 0x70, 0x3a, 0x4b, 0x3e, 0x66, 0xdf, 0x2c, 0xc5, 0x9b, 0xe5, 0xe3,
+ 0xa9, 0xe6, 0x44, 0x55,
+ ],
+ [
+ 0xcb, 0x59, 0x0c, 0x31, 0x22, 0x0d, 0xd3, 0x0c, 0x6c, 0x4a, 0x82, 0x9d, 0xcd,
+ 0xec, 0xb0, 0xa8, 0xe4, 0xa2, 0xa1, 0xf6,
+ ],
+ [
+ 0x8e, 0xfa, 0x25, 0xbd, 0x3d, 0x3a, 0xc8, 0x61, 0xb7, 0x3f, 0x6b, 0x64, 0xbc,
+ 0xea, 0x00, 0xe0, 0xda, 0xb8, 0xd0, 0xe7, 0x62, 0x89, 0xac, 0x1f, 0x0c, 0x35,
+ 0xac, 0xad, 0x5a, 0x46, 0x6e, 0x51,
+ ],
+ [
+ 0x95, 0x87, 0x5b, 0xad, 0x5b, 0x7c, 0x01, 0x8e, 0x0e, 0x45, 0x40, 0xae, 0x08,
+ 0x93, 0xcd, 0xa4, 0xcb, 0xa9, 0x50, 0x92, 0xc6, 0xe7, 0x9d, 0xf2, 0xe4, 0x74,
+ 0xa0, 0xd4, 0x95, 0x11, 0x02, 0x81, 0x1a, 0xc2, 0x33, 0x95, 0xf4, 0x95, 0xac,
+ 0x35, 0xea, 0xd4, 0x7c, 0x37, 0x4f, 0xc9, 0x42, 0x5f,
+ ],
+ [
+ 0x1e, 0xfe, 0x41, 0xfd, 0x93, 0xbf, 0x30, 0x32, 0xd3, 0x59, 0x4d, 0xad, 0xab,
+ 0xc6, 0xcd, 0x4a, 0x97, 0xf2, 0x8e, 0x21, 0x02, 0x83, 0x6a, 0x65, 0xc7, 0x34,
+ 0xf5, 0xcf, 0x38, 0xd2, 0xee, 0x16, 0x3c, 0x5f, 0xbc, 0x5a, 0xde, 0x09, 0x72,
+ 0x17, 0x02, 0x11, 0xa9, 0x63, 0x47, 0x09, 0xe0, 0xac, 0xcf, 0x35, 0x43, 0x14,
+ 0xae, 0x95, 0x4b, 0x0c, 0xb6, 0x06, 0x13, 0xb5, 0xf2, 0x5b, 0x5d, 0xfa,
+ ]
+ ),
+ test_case!(
+ [
+ 0xb9, 0xb9, 0x77, 0x32, 0xba, 0x57, 0xa9, 0x2f, 0x6a, 0x3e, 0x17, 0xac, 0xa0,
+ 0xc6, 0xbd, 0x1a, 0x1d, 0x3f, 0x13, 0x29, 0xf7, 0x90, 0xce, 0x20, 0x2b, 0x27,
+ 0xca, 0x26, 0x96, 0x47, 0x1c, 0xbb, 0x72, 0x0b, 0x61, 0x04, 0xec, 0x61, 0xdb,
+ 0xe3, 0xde, 0xac, 0x52, 0xf7, 0x22, 0xde, 0xde, 0x6c, 0x6c, 0x44, 0x5f, 0x7d,
+ 0xf4, 0xcd, 0xf9, 0xff, 0xe0, 0x4f, 0x20, 0xd0, 0x86, 0x61, 0x0f, 0x12, 0x27,
+ 0x94, 0xbd, 0xad, 0xd3, 0xa0, 0xa0, 0xca, 0xdc, 0x96, 0x51, 0x8c, 0x05, 0xb6,
+ 0x6f, 0xbd, 0x58, 0xc3, 0x57, 0x12, 0x72, 0x59, 0x02, 0xda, 0x42, 0xf8, 0x72,
+ 0xa4, 0xbd, 0x17, 0x20, 0xd2, 0x0d, 0x2e, 0x7f, 0x94, 0xb5, 0x87, 0x3a, 0x49,
+ 0x3a, 0x7b, 0x8d, 0xd9, 0xee, 0x8d, 0x37, 0xb8, 0x52, 0x8a, 0xfe, 0x52, 0x9d,
+ 0xe8, 0xe4, 0xae, 0xce, 0x5d,
+ ],
+ [
+ 0x0b, 0xb8, 0x37, 0xfc, 0xec, 0x5d, 0x07, 0x8f, 0x58, 0x45, 0xb4, 0x01, 0x12,
+ 0x74, 0x84, 0xf1, 0xe6, 0x95, 0x24, 0x1f,
+ ],
+ [
+ 0x85, 0x02, 0x8b, 0x5a, 0x6a, 0x92, 0xe3, 0x88, 0x57, 0x20, 0x36, 0x78, 0x23,
+ 0x4b, 0x11, 0x21, 0x4d, 0x67, 0x9d, 0x9f, 0x8a, 0x34, 0xab, 0xad, 0x97, 0x45,
+ 0x6f, 0x14, 0x8f, 0x60, 0x67, 0x1a,
+ ],
+ [
+ 0x47, 0x95, 0x35, 0x81, 0x04, 0xef, 0xdc, 0xb5, 0xc3, 0x0c, 0xe4, 0x35, 0x5d,
+ 0x36, 0xd5, 0xe7, 0x03, 0x78, 0x06, 0x06, 0x48, 0x8f, 0x7b, 0xd6, 0x87, 0xa7,
+ 0xcb, 0x8c, 0x4b, 0x34, 0x58, 0xcd, 0xcc, 0x69, 0xb5, 0x6b, 0x9b, 0xf9, 0xff,
+ 0xa9, 0x1a, 0x71, 0x84, 0x46, 0x67, 0x4e, 0xaf, 0xae,
+ ],
+ [
+ 0x30, 0x83, 0x6e, 0x51, 0x41, 0x81, 0x6a, 0xc4, 0x82, 0x79, 0xcd, 0x74, 0x18,
+ 0x06, 0xc2, 0x8f, 0x8a, 0xc7, 0x9b, 0x4e, 0xdf, 0x0c, 0xda, 0x0b, 0xad, 0x4f,
+ 0xee, 0xe2, 0x56, 0x97, 0x03, 0x29, 0xde, 0x6d, 0xe7, 0x6b, 0xc6, 0x6c, 0x58,
+ 0x9e, 0xc8, 0x93, 0xb8, 0x47, 0x6e, 0x7d, 0x02, 0xd5, 0x54, 0x28, 0x6d, 0xe0,
+ 0x46, 0x78, 0xa7, 0x92, 0x54, 0x52, 0x7d, 0x56, 0xf7, 0xec, 0x21, 0x2a,
+ ]
+ ),
+ test_case!(
+ [
+ 0x63, 0x78, 0x65, 0x8e, 0xb3, 0xac, 0xd1, 0xcc, 0x65, 0x2c, 0x9c, 0xdf, 0x37,
+ 0x94, 0xe2, 0x87, 0x22, 0x7e, 0x19, 0x12, 0x75, 0x92, 0xa6, 0x2f, 0xf1, 0x9c,
+ 0x64, 0x0d, 0x1f, 0xff, 0x53, 0x52, 0x52, 0xd2, 0x7c, 0x32, 0xff, 0x19, 0x5d,
+ 0xe6, 0x9a, 0x4f, 0x75, 0x2c, 0x67, 0x6d, 0x45, 0xb7, 0x4d, 0x19, 0x5a, 0xa1,
+ 0x31, 0x90, 0x99, 0xad, 0xd9, 0xac, 0x07, 0xe4, 0xe5, 0xec, 0xa5, 0x17, 0xcb,
+ 0xb6, 0x77, 0xac, 0x76, 0x9d, 0xf9, 0xb4, 0xae, 0xca, 0xd1, 0xf5, 0xb6, 0x87,
+ 0x86, 0x1a, 0x8b, 0xb3, 0x43, 0x78, 0x4d, 0x58, 0x43, 0x8a, 0xe4, 0xa0, 0xc0,
+ 0xb3, 0x18, 0xcb, 0x6d, 0x18, 0x9a, 0xbd, 0x52, 0xae, 0x55, 0x83, 0xf7, 0x3f,
+ 0x23, 0x79, 0xd5, 0xd9, 0x75, 0x71, 0x1d, 0x44, 0x0b, 0xf7, 0x3b, 0xd8, 0x48,
+ 0xb7, 0x14, 0xd8, 0xc8, 0x38, 0xf9,
+ ],
+ [
+ 0x98, 0x10, 0x57, 0x64, 0xe2, 0x3e, 0x6b, 0xfa, 0x2a, 0x17, 0xa7, 0x62, 0x3f,
+ 0x87, 0xa6, 0x4c, 0xd1, 0x5e, 0x60, 0xa9,
+ ],
+ [
+ 0xdb, 0xb5, 0xd7, 0x61, 0x38, 0xd5, 0x72, 0x48, 0xb2, 0xc7, 0x8d, 0x6a, 0xaf,
+ 0xff, 0xfd, 0x28, 0x52, 0x6c, 0x12, 0x84, 0x9a, 0xd4, 0xb6, 0x4c, 0x9b, 0xdb,
+ 0x2a, 0xf7, 0x8c, 0x7d, 0x93, 0xb9,
+ ],
+ [
+ 0x1f, 0x47, 0x25, 0xfd, 0x3a, 0x34, 0x91, 0xf6, 0x46, 0x8e, 0x05, 0xad, 0xeb,
+ 0x19, 0x34, 0x0b, 0x77, 0x16, 0xec, 0xf1, 0x8d, 0xfd, 0xf8, 0x3d, 0x64, 0xcb,
+ 0x43, 0xf4, 0xe9, 0xfb, 0xde, 0x78, 0xfd, 0x5b, 0x0b, 0xcf, 0xcb, 0x1b, 0x55,
+ 0x52, 0x67, 0xe0, 0x39, 0x08, 0x07, 0x00, 0x7a, 0x6a,
+ ],
+ [
+ 0xff, 0xac, 0xcc, 0xc4, 0x5d, 0x2e, 0xac, 0x44, 0xb2, 0x00, 0xe8, 0x5d, 0xe9,
+ 0xcc, 0xab, 0x34, 0x25, 0x33, 0x35, 0x02, 0x2c, 0x6d, 0x4f, 0x9f, 0x8f, 0x44,
+ 0x80, 0xb5, 0x1d, 0x96, 0x0d, 0xb9, 0xdc, 0xc9, 0x87, 0x87, 0x90, 0x5c, 0xb4,
+ 0x99, 0x2d, 0xd9, 0x27, 0xe6, 0x2b, 0x44, 0x4d, 0xf7, 0x4a, 0x09, 0xd3, 0x96,
+ 0x2c, 0x56, 0xd5, 0xbe, 0x61, 0xd9, 0x66, 0x25, 0xcd, 0x5a, 0x15, 0xb4,
+ ]
+ ),
+ test_case!(
+ [
+ 0x02, 0xd3, 0xa6, 0xc6, 0x81, 0xfb, 0x18, 0x43, 0xf4, 0xf4, 0x43, 0xf8, 0x0b,
+ 0xd6, 0x9f, 0xda, 0x40, 0x8a, 0x16, 0xf8, 0x9e, 0x8c, 0x7f, 0xcd, 0x09, 0x05,
+ 0x49, 0x34, 0xe3, 0x4e, 0x88, 0xc7, 0x4d, 0xb3, 0x75, 0x14, 0x01, 0xa7, 0x24,
+ 0x53, 0xfd, 0x74, 0x8b, 0xc5, 0x29, 0x32, 0x1b, 0xd7, 0x7a, 0xe8, 0xcd, 0xb3,
+ 0x93, 0xfe, 0x08, 0xd2, 0x23, 0xd0, 0x7e, 0xfa, 0x42, 0xe0, 0x22, 0xd9, 0x07,
+ 0x13, 0x45, 0x44, 0xa7, 0xec, 0x16, 0x9a, 0x5e, 0x40, 0x23, 0xc9, 0xc6, 0x34,
+ 0x71, 0x85, 0x28, 0x19, 0x2c, 0xf2, 0xd5, 0xdf, 0xb9, 0xb4, 0x7a, 0x89, 0x80,
+ 0x84, 0x35, 0xb5, 0x45, 0x47, 0xff, 0x0d, 0xc1, 0x0d, 0xf7, 0x90, 0xb0, 0x74,
+ 0x34, 0x90, 0xf2, 0x60, 0x76, 0xdc, 0xd9, 0xc2, 0xfd, 0x9e, 0x3c, 0xbf, 0x6c,
+ 0xd1, 0xa0, 0x14, 0x7a, 0x51, 0xdb, 0x8a,
+ ],
+ [
+ 0x09, 0x96, 0x75, 0xe1, 0x79, 0xa2, 0xb8, 0x75, 0x8c, 0x75, 0x3c, 0x68, 0x22,
+ 0xdd, 0x3a, 0xaa, 0x65, 0x80, 0x02, 0xc6,
+ ],
+ [
+ 0x36, 0x64, 0xd4, 0xe4, 0xb5, 0x7d, 0x8a, 0xdc, 0x8d, 0x9c, 0x63, 0xc1, 0xd1,
+ 0xf4, 0xc4, 0x01, 0x2f, 0xaa, 0xcf, 0xc2, 0x1d, 0xc3, 0xc5, 0xed, 0x83, 0xd2,
+ 0x5f, 0xe3, 0xff, 0x18, 0x29, 0x03,
+ ],
+ [
+ 0x94, 0xfc, 0xb9, 0xb8, 0x0f, 0x81, 0xf4, 0x42, 0xf9, 0x34, 0xf7, 0xed, 0x5a,
+ 0xc0, 0x67, 0xa6, 0x77, 0x21, 0xbd, 0x72, 0x26, 0x2c, 0x98, 0xfd, 0x99, 0x48,
+ 0xe5, 0x19, 0xa2, 0xd2, 0xda, 0xc3, 0xf7, 0xe0, 0x13, 0xa5, 0x84, 0xeb, 0xa9,
+ 0x28, 0x38, 0x76, 0x8a, 0xa5, 0x7d, 0xdf, 0xd1, 0x23,
+ ],
+ [
+ 0x52, 0x1c, 0x97, 0xac, 0xc3, 0x0d, 0x13, 0x19, 0xcd, 0x3c, 0x10, 0x4c, 0x89,
+ 0x67, 0x49, 0x59, 0xad, 0x14, 0xbe, 0xc9, 0xf6, 0x46, 0xb8, 0xb6, 0x3b, 0x3d,
+ 0x29, 0xc8, 0x03, 0x00, 0x00, 0x6e, 0x5e, 0x41, 0x5d, 0xf8, 0xae, 0x2e, 0x4f,
+ 0x80, 0x6c, 0x0d, 0x8d, 0xe9, 0x65, 0x5a, 0xba, 0x13, 0x89, 0xc1, 0xc5, 0x28,
+ 0x2b, 0x0b, 0x42, 0x34, 0xab, 0x3f, 0x6c, 0xba, 0x3e, 0x71, 0x30, 0x5e,
+ ]
+ ),
+ test_case!(
+ [
+ 0x52, 0x71, 0x17, 0x1e, 0xa3, 0x8b, 0xe0, 0x4c, 0x92, 0xe6, 0xf5, 0x6e, 0xe4,
+ 0xf5, 0xab, 0xc4, 0x94, 0x29, 0x9b, 0xa6, 0x09, 0x44, 0x5e, 0xe0, 0x54, 0x3f,
+ 0x1d, 0xa8, 0x67, 0xe6, 0xb7, 0x94, 0x9d, 0x32, 0x5f, 0x40, 0x56, 0x0e, 0x6a,
+ 0xfd, 0xab, 0x54, 0xb2, 0x26, 0xae, 0xa0, 0xe7, 0x02, 0x78, 0x7b, 0x4c, 0xf4,
+ 0x88, 0xe6, 0x96, 0xe0, 0x91, 0xa9, 0x1f, 0xb8, 0x8f, 0x2e, 0x63, 0xd3, 0xe4,
+ 0x9f, 0xdf, 0xdb, 0x69, 0x60, 0xd0, 0xb2, 0x32, 0x57, 0xa9, 0x13, 0xc0, 0x1c,
+ 0x7a, 0x89, 0x2f, 0x6d, 0x3c, 0x27, 0x95, 0xae, 0x4b, 0x75, 0xb8, 0xdb, 0x97,
+ 0x6b, 0xf2, 0xea, 0x92, 0xfc, 0xb3, 0xf0, 0x57, 0xf8, 0x29, 0xcf, 0x49, 0x86,
+ 0x3a, 0xa3, 0x80, 0x9b, 0x60, 0x2f, 0xc3, 0xce, 0xe6, 0x3f, 0x18, 0x00, 0x20,
+ 0xf4, 0x48, 0x8e, 0x4a, 0xf2, 0xf3, 0x07, 0x2f,
+ ],
+ [
+ 0x37, 0x28, 0xa7, 0x30, 0x08, 0xfd, 0x65, 0xf8, 0xc9, 0xb3, 0x6c, 0x77, 0x7a,
+ 0xe3, 0x57, 0x5b, 0xd3, 0x96, 0x90, 0x0f,
+ ],
+ [
+ 0xfe, 0x48, 0xad, 0xe6, 0xea, 0xfe, 0x62, 0x31, 0xb6, 0x47, 0x90, 0x3e, 0x16,
+ 0xc5, 0xec, 0x5b, 0x1b, 0x97, 0x36, 0xd1, 0x8f, 0xc6, 0x5d, 0xb0, 0x08, 0xa5,
+ 0x7d, 0xe4, 0xbd, 0x8c, 0x69, 0x83,
+ ],
+ [
+ 0x7d, 0xea, 0x9e, 0xa0, 0x7a, 0x8c, 0xc7, 0x0f, 0x7f, 0x29, 0xfb, 0xfa, 0x76,
+ 0xf2, 0x3e, 0x59, 0xc0, 0xd0, 0x51, 0xa6, 0x5b, 0x6f, 0x54, 0x4e, 0x6b, 0x2e,
+ 0xc8, 0x4c, 0x12, 0x69, 0x1e, 0x3e, 0x10, 0x48, 0x88, 0xbb, 0x23, 0x13, 0xae,
+ 0xd4, 0xfd, 0x7b, 0x0c, 0x4a, 0x97, 0xbd, 0xd7, 0x0d,
+ ],
+ [
+ 0x26, 0xd5, 0xab, 0x59, 0x27, 0x26, 0xa4, 0x6a, 0x3f, 0x68, 0xb3, 0xeb, 0xb6,
+ 0x56, 0xf5, 0x86, 0xb7, 0xa1, 0x83, 0x45, 0xc0, 0xd6, 0x70, 0xc0, 0x53, 0x93,
+ 0x97, 0x3b, 0xbe, 0x31, 0x68, 0x12, 0x5e, 0xcf, 0x81, 0xeb, 0x9f, 0xad, 0x05,
+ 0xba, 0x6a, 0x71, 0xb4, 0x3f, 0xc6, 0x37, 0x37, 0xda, 0x8a, 0xfd, 0x72, 0xc7,
+ 0x64, 0xdd, 0xc8, 0x03, 0x6c, 0x2c, 0xe5, 0x6c, 0x31, 0x96, 0x43, 0x4c,
+ ]
+ ),
+ test_case!(
+ [
+ 0xa2, 0x1f, 0x1d, 0xbf, 0xa8, 0x19, 0xdc, 0x26, 0x18, 0x5c, 0x30, 0x7c, 0x04,
+ 0xb0, 0x24, 0x95, 0xc3, 0x2c, 0x0b, 0x28, 0xc5, 0xe4, 0xad, 0x7e, 0x0c, 0xf5,
+ 0x17, 0x8c, 0xd8, 0x3c, 0xe7, 0xf7, 0xa2, 0x4a, 0x11, 0x50, 0xac, 0x0b, 0x76,
+ 0x37, 0xfb, 0x14, 0x59, 0x50, 0x66, 0x76, 0x8d, 0x32, 0x68, 0xff, 0x06, 0x82,
+ 0xa4, 0xed, 0x19, 0x74, 0x2a, 0x49, 0x1e, 0xa4, 0xe1, 0x04, 0x85, 0xad, 0x9c,
+ 0xcf, 0x4b, 0x7c, 0x18, 0x76, 0x0d, 0xda, 0xbb, 0x27, 0x4f, 0xdd, 0x29, 0x5d,
+ 0xc7, 0xe8, 0x45, 0x47, 0x7c, 0xe4, 0x6f, 0xb8, 0x1f, 0xc1, 0xb1, 0x9b, 0x5d,
+ 0x83, 0x40, 0x75, 0xf6, 0x97, 0x11, 0x06, 0xd4, 0x03, 0x9f, 0x8b, 0x46, 0x0a,
+ 0xe9, 0xdd, 0xcc, 0x73, 0xa9, 0x26, 0xec, 0x06, 0x82, 0xa1, 0x2f, 0xc1, 0x9e,
+ 0xbe, 0x81, 0x92, 0x75, 0x6e, 0x00, 0x10, 0x3d, 0x0c,
+ ],
+ [
+ 0x2e, 0x19, 0xba, 0x7d, 0x5f, 0x43, 0x6f, 0x2c, 0x78, 0x46, 0x0d, 0x60, 0xa3,
+ 0x4b, 0x44, 0xb5, 0x82, 0x94, 0x98, 0xfc,
+ ],
+ [
+ 0xa1, 0x7b, 0xe9, 0xb2, 0x58, 0xb1, 0xe0, 0xa0, 0xb4, 0xa0, 0x53, 0x84, 0x8e,
+ 0x25, 0xb0, 0xf1, 0xbd, 0x30, 0x7f, 0x66, 0x4c, 0x99, 0xbf, 0xaf, 0x5b, 0x2d,
+ 0x82, 0x8b, 0xef, 0x08, 0x4e, 0x2d,
+ ],
+ [
+ 0x01, 0xd0, 0x3c, 0xf8, 0xe7, 0x90, 0x54, 0x62, 0x95, 0xef, 0xc3, 0x35, 0x6a,
+ 0x9f, 0x6b, 0x49, 0x9c, 0x3a, 0x44, 0x5e, 0xa6, 0x62, 0x21, 0x81, 0xd7, 0xae,
+ 0xad, 0xba, 0xd3, 0x20, 0x97, 0xa3, 0xc2, 0xbb, 0x26, 0xa7, 0x80, 0x73, 0xc6,
+ 0xb0, 0x78, 0xf1, 0x4b, 0x9f, 0xbc, 0xe8, 0x69, 0x77,
+ ],
+ [
+ 0x91, 0x5f, 0x90, 0xe3, 0x8d, 0x1f, 0xa0, 0xf6, 0x53, 0x71, 0x7c, 0x05, 0x9d,
+ 0x85, 0x50, 0xf3, 0x59, 0xe4, 0xaa, 0x98, 0x59, 0x33, 0x59, 0x30, 0x7e, 0x56,
+ 0x00, 0x93, 0xa4, 0xf1, 0xb5, 0x05, 0x0d, 0xad, 0xb6, 0xdf, 0x7e, 0xea, 0x32,
+ 0xb9, 0xfb, 0xd2, 0x48, 0x2f, 0x1d, 0xc8, 0x98, 0x3b, 0x51, 0xe2, 0xdb, 0x88,
+ 0xf5, 0x61, 0xcf, 0x3d, 0x85, 0x6f, 0x6f, 0xfc, 0x50, 0x35, 0x4c, 0xc4,
+ ]
+ ),
+ test_case!(
+ [
+ 0x11, 0xf6, 0x3f, 0x5c, 0x17, 0x7b, 0x67, 0x52, 0x23, 0x61, 0x77, 0x79, 0xef,
+ 0x95, 0xf6, 0xe1, 0xca, 0x73, 0xbf, 0x4f, 0xe9, 0xd1, 0x00, 0x37, 0xc0, 0x23,
+ 0x2f, 0x85, 0xb8, 0xb6, 0xa0, 0x54, 0x83, 0x36, 0x02, 0xe3, 0xb5, 0x7b, 0xc3,
+ 0x9c, 0x72, 0xc4, 0x4b, 0x90, 0x64, 0x46, 0x63, 0xa5, 0x6a, 0x76, 0x5e, 0x9a,
+ 0x78, 0xeb, 0xa1, 0x1b, 0x94, 0xde, 0x9a, 0x35, 0x29, 0x61, 0x3f, 0x76, 0xb9,
+ 0xdf, 0x8e, 0x49, 0x47, 0xe4, 0x0c, 0xd4, 0xcc, 0x5e, 0xda, 0x97, 0xda, 0x89,
+ 0xcd, 0xe6, 0x9e, 0x43, 0x58, 0x1b, 0x15, 0x0d, 0x5a, 0x3a, 0xe8, 0xdd, 0x71,
+ 0xa9, 0xbe, 0x0c, 0x10, 0xea, 0x95, 0xc2, 0x45, 0x72, 0xdf, 0xf0, 0xb6, 0xf2,
+ 0xb1, 0x2d, 0x80, 0xe0, 0x08, 0x54, 0xc9, 0x54, 0xdf, 0xb7, 0x40, 0xb2, 0x3b,
+ 0x67, 0xa2, 0x61, 0x08, 0x78, 0x1e, 0x46, 0xfe, 0x1a, 0x5a,
+ ],
+ [
+ 0xd7, 0x7a, 0xd5, 0xf6, 0xf9, 0xb6, 0xff, 0xd6, 0x41, 0x81, 0x23, 0xa3, 0xa3,
+ 0xcd, 0x4c, 0x43, 0x3b, 0x65, 0x62, 0xe7,
+ ],
+ [
+ 0xbc, 0xaf, 0xe5, 0x98, 0x2f, 0x9d, 0x5b, 0xf6, 0x33, 0x40, 0x37, 0xbc, 0x64,
+ 0x7e, 0x34, 0x59, 0xf9, 0xcf, 0x91, 0xb3, 0x87, 0xd8, 0x8c, 0x20, 0x69, 0x93,
+ 0x5b, 0xb5, 0x86, 0x55, 0x4c, 0x39,
+ ],
+ [
+ 0xa7, 0x8f, 0xd1, 0xbd, 0xf8, 0x42, 0x56, 0x3d, 0x3d, 0xcc, 0xe2, 0x17, 0x29,
+ 0x80, 0xf6, 0x3d, 0xa7, 0x13, 0x28, 0x2e, 0x26, 0xe1, 0x06, 0x92, 0x1f, 0x24,
+ 0x45, 0xfb, 0x11, 0x84, 0xb0, 0xe8, 0x2c, 0xc0, 0xb5, 0xec, 0xd9, 0xdb, 0x56,
+ 0xa8, 0x7d, 0x34, 0x0d, 0x31, 0xf3, 0x63, 0xa0, 0x31,
+ ],
+ [
+ 0xd5, 0x7c, 0xc3, 0xf0, 0x6b, 0x67, 0xc9, 0x0b, 0x56, 0x50, 0x3d, 0x47, 0xfa,
+ 0x14, 0xf3, 0xac, 0xca, 0xb1, 0xb6, 0xa0, 0x15, 0xc6, 0x1f, 0x38, 0x53, 0x5f,
+ 0xec, 0xd7, 0x2b, 0x3c, 0x0a, 0x45, 0xa7, 0x6d, 0x17, 0xe1, 0x66, 0x76, 0xcd,
+ 0xd1, 0x68, 0x9c, 0x5a, 0xed, 0xe3, 0x85, 0x57, 0xc9, 0xb7, 0xd4, 0x84, 0x7a,
+ 0x70, 0x0d, 0x4c, 0xaa, 0x58, 0xdc, 0xea, 0xf1, 0x6c, 0xd9, 0xfe, 0x81,
+ ]
+ ),
+ test_case!(
+ [
+ 0x5e, 0x94, 0x43, 0x8d, 0xa3, 0x9d, 0x5b, 0xfc, 0xcc, 0x3c, 0x68, 0xfb, 0xe7,
+ 0x50, 0xba, 0x4e, 0x15, 0x6f, 0x7a, 0xd6, 0xf0, 0x16, 0xaa, 0xda, 0xd2, 0x95,
+ 0xc7, 0x2f, 0x17, 0x7f, 0x3f, 0xae, 0xa5, 0x09, 0x19, 0x50, 0x97, 0x33, 0x1e,
+ 0x75, 0x3d, 0xa2, 0x37, 0x3b, 0x05, 0x46, 0xc1, 0xa8, 0x38, 0xa1, 0x44, 0xcd,
+ 0xf8, 0x4b, 0x8c, 0x55, 0xda, 0x6a, 0x24, 0xf0, 0xba, 0x57, 0xc8, 0xfb, 0x4c,
+ 0x9a, 0xe3, 0x90, 0xf7, 0x72, 0xe7, 0x52, 0x0f, 0x30, 0x7b, 0xc1, 0x21, 0x7d,
+ 0xce, 0xa9, 0x03, 0x72, 0x58, 0x3a, 0x69, 0x16, 0xa8, 0x06, 0xc7, 0x54, 0x0a,
+ 0xd9, 0xe8, 0x24, 0x62, 0xca, 0x70, 0x6c, 0x83, 0xa0, 0x38, 0x4a, 0xbb, 0x64,
+ 0x93, 0x7a, 0x4a, 0xad, 0xf3, 0x4f, 0x69, 0xc6, 0xa0, 0x79, 0x46, 0x36, 0x89,
+ 0xbc, 0x20, 0x97, 0xd8, 0x39, 0x72, 0x80, 0x48, 0x3a, 0xb2, 0x02,
+ ],
+ [
+ 0x9a, 0xe9, 0x8b, 0xe9, 0xf1, 0x3a, 0x2e, 0xe0, 0x83, 0x5d, 0x8c, 0x53, 0xd2,
+ 0xcf, 0xe3, 0x27, 0xb9, 0x08, 0x1d, 0xc7,
+ ],
+ [
+ 0x1c, 0xf3, 0x32, 0x90, 0x6d, 0x9e, 0x0f, 0x30, 0x81, 0x75, 0xf5, 0xbc, 0x7d,
+ 0xcc, 0xd4, 0x79, 0xa1, 0xf2, 0xfc, 0xfb, 0xc6, 0xf2, 0x40, 0xb0, 0x41, 0xb9,
+ 0xa0, 0x60, 0x98, 0x24, 0x7d, 0x96,
+ ],
+ [
+ 0x5c, 0xb0, 0x2f, 0xff, 0x06, 0x0b, 0xbc, 0x64, 0x8b, 0x8b, 0x8f, 0x47, 0x26,
+ 0x8c, 0x82, 0xfd, 0x70, 0x0d, 0x9e, 0x53, 0xf2, 0x08, 0x3b, 0x56, 0xb1, 0x26,
+ 0xa2, 0x98, 0x68, 0x80, 0xd7, 0x4f, 0x53, 0xf5, 0x57, 0x87, 0x12, 0x3d, 0xcc,
+ 0xfd, 0xe0, 0x69, 0x27, 0x08, 0x84, 0xb3, 0x3c, 0x41,
+ ],
+ [
+ 0x6b, 0xb5, 0xb1, 0xcc, 0xa3, 0x0e, 0xa2, 0xdf, 0x18, 0x4f, 0x25, 0x61, 0xae,
+ 0xfa, 0x1c, 0x1d, 0x19, 0xb6, 0x9b, 0x33, 0xf9, 0xa6, 0xfd, 0x96, 0xc3, 0xd7,
+ 0x06, 0xb0, 0x82, 0x32, 0xa1, 0xba, 0x49, 0xbc, 0xda, 0xdb, 0x02, 0x2d, 0xbf,
+ 0x4c, 0xf6, 0x20, 0xab, 0x41, 0xd1, 0xbe, 0x75, 0xbf, 0xab, 0xbb, 0xd9, 0x54,
+ 0x11, 0x24, 0x87, 0xb5, 0xbe, 0x57, 0xbd, 0xca, 0xd8, 0xa9, 0x22, 0x6c,
+ ]
+ ),
+ ];
+ }
+}
diff --git a/src/hmac.rs b/src/hmac.rs
new file mode 100644
index 0000000..2a32cf5
--- /dev/null
+++ b/src/hmac.rs
@@ -0,0 +1,4220 @@
+// Copyright 2018 Google LLC
+//
+// Use of this source code is governed by an MIT-style
+// license that can be found in the LICENSE file or at
+// https://opensource.org/licenses/MIT.
+
+//! Hash-based Message Authentication Codes (HMACs).
+
+use std::fmt::{self, Debug, Formatter};
+use std::marker::PhantomData;
+
+use boringssl::{self, CStackWrapper};
+use hash::{inner::Digest, Hasher, Sha256, Sha384, Sha512};
+
+/// A Hash-based Message Authentication Code (HMAC).
+///
+/// `Hmac` is an HMAC over the hash function `H`.
+#[must_use]
+pub struct Hmac<H: Hasher> {
+ ctx: CStackWrapper<boringssl::HMAC_CTX>,
+ _marker: PhantomData<H>,
+}
+
+impl<H: Hasher> Hmac<H> {
+ /// Constructs a new HMAC.
+ #[must_use]
+ pub fn new(key: &[u8]) -> Hmac<H> {
+ // TODO(joshlf): Do we want to put any constraints on what constitutes a
+ // valid key?
+ Hmac {
+ // hmac_ctx_new can only fail due to OOM
+ ctx: CStackWrapper::hmac_ctx_new(key, &H::evp_md()).unwrap(),
+ _marker: PhantomData,
+ }
+ }
+
+ /// Adds bytes to the HMAC.
+ pub fn update(&mut self, bytes: &[u8]) {
+ self.ctx.hmac_update(bytes);
+ }
+
+ /// Returns the HMAC of the bytes added so far.
+ #[must_use]
+ pub fn finish(mut self) -> H::Digest {
+ let mut out = H::Digest::zero();
+ self.ctx.hmac_final(out.as_mut());
+ out
+ }
+}
+
+impl<H: Hasher> Debug for Hmac<H> {
+ fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> {
+ write!(f, "Hmac")
+ }
+}
+
+/// HMAC-SHA256.
+pub type HmacSha256 = Hmac<Sha256>;
+/// HMAC-SHA384.
+pub type HmacSha384 = Hmac<Sha384>;
+/// HMAC-SHA512.
+pub type HmacSha512 = Hmac<Sha512>;
+
+/// Computes the HMAC of a sequence of bytes under a key.
+///
+/// `hmac` creates a new instance of `Hmac<H>` using the key `key`, adds `bytes`
+/// to it, and then computes the HMAC.
+#[must_use]
+pub fn hmac<H: Hasher>(key: &[u8], bytes: &[u8]) -> H::Digest {
+ let mut hmac = Hmac::<H>::new(key);
+ hmac.update(bytes);
+ hmac.finish()
+}
+
+#[cfg(feature = "insecure")]
+pub(crate) mod insecure_hmac_sha1 {
+ #[allow(deprecated)]
+ use hash::{insecure_sha1_digest::InsecureSha1Digest, InsecureSha1};
+ use hmac::Hmac;
+
+ // NOTE(joshlf): It's important that InsecureHmacSha1 is a new type rather
+ // than a type alias for Hmac<Sha1>. If it were the latter, then client code
+ // could use this to coax a type parameter into taking on the type Sha1, and
+ // could thus construct SHA-1 hashes directly, which we explicitly wish to
+ // avoid.
+
+ /// INSECURE: The Hash-based Message Authentication Code (HMAC) over SHA-1.
+ ///
+ /// # Security
+ ///
+ /// HMAC-SHA1 is considered insecure, and should only be used for compatibility
+ /// with legacy applications.
+ #[deprecated(note = "HMAC-SHA1 is considered insecure")]
+ pub struct InsecureHmacSha1 {
+ #[allow(deprecated)]
+ hmac: Hmac<InsecureSha1>,
+ }
+
+ #[allow(deprecated)]
+ impl InsecureHmacSha1 {
+ /// INSECURE: Constructs a new HMAC-SHA1.
+ ///
+ /// # Security
+ ///
+ /// HMAC-SHA1 is considered insecure, and should only be used for
+ /// compatibility with legacy applications.
+ #[must_use]
+ #[deprecated(note = "HMAC-SHA1 is considered insecure")]
+ pub fn insecure_new(key: &[u8]) -> InsecureHmacSha1 {
+ InsecureHmacSha1 {
+ hmac: Hmac::new(key),
+ }
+ }
+
+ /// INSECURE: Adds bytes to the HMAC-SHA1.
+ ///
+ /// # Security
+ ///
+ /// HMAC-SHA1 is considered insecure, and should only be used for
+ /// compatibility with legacy applications.
+ #[must_use]
+ #[deprecated(note = "HMAC-SHA1 is considered insecure")]
+ pub fn insecure_update(&mut self, bytes: &[u8]) {
+ self.hmac.update(bytes);
+ }
+
+ /// INSECURE: Returns the HMAC-SHA1 of the bytes added so far.
+ ///
+ /// # Security
+ ///
+ /// HMAC-SHA1 is considered insecure, and should only be used for
+ /// compatibility with legacy applications.
+ #[must_use]
+ #[deprecated(note = "HMAC-SHA1 is considered insecure")]
+ pub fn insecure_finish(self) -> InsecureSha1Digest {
+ self.hmac.finish()
+ }
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ #[cfg(feature = "insecure")]
+ #[allow(deprecated)]
+ use hash::insecure_sha1_digest::InsecureSha1Digest;
+ use hash::*;
+
+ #[test]
+ fn test_hmac() {
+ struct TestCase {
+ input: &'static [u8],
+ #[cfg(feature = "insecure")]
+ #[allow(deprecated)]
+ sha1: <InsecureSha1 as Hasher>::Digest,
+ sha256: <Sha256 as Hasher>::Digest,
+ sha384: <Sha384 as Hasher>::Digest,
+ sha512: <Sha512 as Hasher>::Digest,
+ }
+
+ for case in TEST_CASES.iter() {
+ fn test<H: Hasher>(input: &'static [u8], digest: &H::Digest) {
+ assert_eq!(&hmac::<H>(TEST_KEY, input), digest, "input: {:?}", input);
+ // Test that adding bytes incrementally works too.
+ let mut hmac = Hmac::<H>::new(TEST_KEY);
+ for b in input {
+ hmac.update(&[*b]);
+ }
+ assert_eq!(&hmac.finish(), digest, "input: {:?}", input);
+ }
+ #[cfg(feature = "insecure")]
+ #[allow(deprecated)]
+ test::<InsecureSha1>(case.input, &case.sha1);
+ test::<Sha256>(case.input, &case.sha256);
+ test::<Sha384>(case.input, &case.sha384);
+ test::<Sha512>(case.input, &case.sha512);
+ }
+
+ macro_rules! test_case {
+ ($input:expr, $sha1:expr, $sha256:expr, $sha384:expr, $sha512:expr) => {
+ #[allow(deprecated)]
+ TestCase {
+ input: &$input,
+ #[cfg(feature = "insecure")]
+ sha1: InsecureSha1Digest($sha1),
+ sha256: Sha256Digest($sha256),
+ sha384: Sha384Digest($sha384),
+ sha512: Sha512Digest($sha512),
+ }
+ };
+ }
+
+ // These test cases were generated using the following script. Each is a
+ // randomly-generated input, with each length between 1 and 128 bytes
+ // represented. The constant key "1482318330" is used.
+ //
+ // # Generate 10000 bytes/20000 hex characters of random data
+ // function rand { dd if=/dev/urandom bs=1 count=10000 | hexdump -ve '1/1 "%.2x"'; }
+ //
+ // # Convert hex to raw bytes
+ // function hex_to_bytes { perl -pe 's/([0-9a-f]{2})/chr hex $1/gie'; }
+ //
+ // # Convert hex to a Rust array
+ // function hex_to_array { echo -n "["; while read -n 2 c; do echo -n "0x${c},";
+ // done; echo "]"; }
+ //
+ // # Usage: hmac <input-hex> <hash>
+ // function hmac { echo -n $(echo -n "$1" | hex_to_bytes | openssl dgst "-${2}" \
+ // -hmac 1482318330 | cut -d ' ' -f 1) | hex_to_array; }
+ //
+ // # Only even numbers of hex characters
+ // for i in `seq 2 2 256`; do
+ // INPUT=$(rand 2>/dev/null | head -c $i);
+ // echo 'test_case!'"($(echo -n ${INPUT} | hex_to_array), $(hash ${INPUT} 1), \
+ // $(hash ${INPUT} 256), $(hash ${INPUT} 384), $(hash ${INPUT} 512)),";
+ // done
+
+ const TEST_KEY: &[u8] = b"1482318330";
+
+ const TEST_CASES: &[TestCase] = &[
+ test_case!(
+ [0x23,],
+ [
+ 0x30, 0xac, 0xcf, 0x23, 0x2c, 0x40, 0x44, 0x84, 0xaf, 0x03, 0xc7, 0x62, 0xb9,
+ 0x28, 0x90, 0x50, 0x39, 0x23, 0x80, 0x30,
+ ],
+ [
+ 0x4a, 0xb9, 0xf8, 0x04, 0xa0, 0x53, 0x6f, 0x10, 0x36, 0xe6, 0x76, 0x93, 0x6c,
+ 0xea, 0x6f, 0x4d, 0x0c, 0xe4, 0x27, 0x88, 0x45, 0x06, 0x3a, 0x88, 0x92, 0x95,
+ 0x5f, 0x15, 0x9d, 0x89, 0x37, 0x88,
+ ],
+ [
+ 0xea, 0xc0, 0xf9, 0x95, 0xca, 0x06, 0x14, 0xd2, 0xc5, 0x0b, 0x7c, 0x82, 0xd0,
+ 0xfd, 0x81, 0x16, 0x8e, 0x05, 0xdd, 0x2b, 0xe4, 0xf8, 0x16, 0xd7, 0xa7, 0x77,
+ 0xaa, 0xf1, 0x5f, 0x40, 0xb3, 0xf0, 0xa3, 0x51, 0x48, 0x38, 0x2d, 0x24, 0x1f,
+ 0x65, 0x8f, 0x11, 0x43, 0x06, 0xf0, 0x8c, 0x67, 0x5d,
+ ],
+ [
+ 0x8d, 0x58, 0x3f, 0xeb, 0x28, 0x38, 0x9c, 0xb2, 0xf6, 0x03, 0xbe, 0x8c, 0x26,
+ 0xa8, 0x7d, 0x44, 0x69, 0x8b, 0xe0, 0x81, 0x74, 0x53, 0x7f, 0xbf, 0x73, 0xa3,
+ 0x0f, 0xfd, 0x5a, 0x50, 0x4d, 0x3b, 0x45, 0xf8, 0x65, 0x5d, 0xdc, 0x40, 0x4d,
+ 0xa4, 0xf3, 0xb5, 0x06, 0x52, 0x36, 0x48, 0x36, 0xa6, 0x61, 0x77, 0x45, 0x31,
+ 0x11, 0x14, 0xb1, 0x05, 0xe3, 0xca, 0x4a, 0x4c, 0x10, 0x7e, 0xf7, 0xdc,
+ ]
+ ),
+ test_case!(
+ [0xbd, 0xcb,],
+ [
+ 0x89, 0x5d, 0xc2, 0xaf, 0x01, 0xbf, 0x7b, 0xa4, 0x35, 0x8c, 0x64, 0xaf, 0x66,
+ 0xc1, 0x74, 0x34, 0x98, 0x57, 0x41, 0xb6,
+ ],
+ [
+ 0xdd, 0x4b, 0x13, 0x72, 0x7d, 0x33, 0x53, 0x5f, 0xe7, 0x1c, 0x42, 0x1c, 0x3d,
+ 0xae, 0xf9, 0x86, 0x98, 0x01, 0x06, 0xfe, 0xf8, 0x71, 0x71, 0xd5, 0xfb, 0x2c,
+ 0xe7, 0x43, 0x88, 0x0a, 0x90, 0x32,
+ ],
+ [
+ 0x0f, 0xdc, 0x20, 0x3d, 0x8c, 0xca, 0xea, 0xb1, 0x94, 0x7e, 0x86, 0x0c, 0x49,
+ 0xfe, 0x83, 0xe2, 0x71, 0x20, 0xf3, 0x5a, 0x29, 0x3c, 0xbb, 0xa5, 0x94, 0x83,
+ 0x76, 0x3d, 0x76, 0x28, 0x23, 0x48, 0xcd, 0x41, 0xb2, 0x19, 0x79, 0x38, 0x66,
+ 0x1c, 0xe4, 0x49, 0xe0, 0x2f, 0x31, 0x1c, 0x06, 0x1d,
+ ],
+ [
+ 0xa2, 0x02, 0x5d, 0x9f, 0xaa, 0x17, 0x2d, 0xdc, 0xe0, 0xd6, 0xd7, 0xf8, 0x38,
+ 0x27, 0x79, 0x02, 0x1c, 0x96, 0xe7, 0xdb, 0xf7, 0x34, 0x61, 0x9f, 0x59, 0xdb,
+ 0xca, 0x05, 0x1d, 0x2c, 0xe9, 0x61, 0x5b, 0xe0, 0xc8, 0x3d, 0x21, 0x2e, 0x07,
+ 0xc6, 0x64, 0x1a, 0xb4, 0xff, 0xd8, 0x85, 0xb4, 0xaf, 0x00, 0x36, 0x4d, 0x8a,
+ 0x50, 0x29, 0x7d, 0xc8, 0x57, 0x08, 0x99, 0xb8, 0x39, 0x3d, 0xc0, 0x3d,
+ ]
+ ),
+ test_case!(
+ [0x2d, 0xfb, 0xa3,],
+ [
+ 0x95, 0x0d, 0xeb, 0xd1, 0x73, 0x6d, 0x4e, 0x81, 0xd3, 0x55, 0x48, 0x4d, 0xba,
+ 0x76, 0xad, 0x38, 0x21, 0xa1, 0x1b, 0x39,
+ ],
+ [
+ 0x11, 0xba, 0x3b, 0x67, 0x72, 0x41, 0x3b, 0x86, 0x01, 0x34, 0x82, 0x3a, 0xb7,
+ 0xdd, 0xa7, 0xc2, 0xd7, 0xa1, 0x95, 0xd5, 0x7a, 0xba, 0xc8, 0xe0, 0xeb, 0xbe,
+ 0xac, 0x81, 0x9d, 0x2d, 0x96, 0xd5,
+ ],
+ [
+ 0x31, 0x4f, 0xff, 0x7e, 0x9f, 0xb8, 0xcc, 0x0e, 0x0f, 0xeb, 0xb6, 0xbe, 0xb5,
+ 0xd4, 0x9c, 0xf7, 0x59, 0x95, 0x61, 0xc7, 0xa9, 0xcd, 0x69, 0x0e, 0xa2, 0xbd,
+ 0x63, 0xad, 0x22, 0x54, 0x86, 0x7c, 0xd8, 0x32, 0xfc, 0x76, 0x12, 0xd4, 0xa3,
+ 0x11, 0x97, 0x24, 0xe9, 0xa9, 0xb0, 0x21, 0xc4, 0x16,
+ ],
+ [
+ 0xd5, 0x6d, 0x41, 0xc0, 0x89, 0xaa, 0x77, 0x64, 0x32, 0xe5, 0x9d, 0xec, 0x92,
+ 0xf2, 0xf6, 0x9e, 0x8c, 0x1f, 0xe4, 0xea, 0xd1, 0x36, 0xa7, 0x3f, 0x89, 0x5f,
+ 0xee, 0xde, 0x5c, 0xdf, 0x3a, 0xb8, 0xe8, 0xe3, 0xfe, 0xd5, 0x4e, 0x37, 0xe0,
+ 0x01, 0xb7, 0xba, 0x17, 0x27, 0xb2, 0x51, 0x73, 0x40, 0x9e, 0x94, 0xd2, 0x0e,
+ 0x38, 0x99, 0x8c, 0x67, 0x8a, 0xaf, 0x9d, 0xb3, 0x79, 0xd9, 0xb1, 0xa9,
+ ]
+ ),
+ test_case!(
+ [0x37, 0x6e, 0xf5, 0x7a,],
+ [
+ 0x14, 0xb0, 0x4a, 0x22, 0x21, 0xbf, 0x4f, 0xb1, 0x87, 0x25, 0x2f, 0xa4, 0xee,
+ 0x52, 0xd7, 0x11, 0x70, 0x64, 0x74, 0xc1,
+ ],
+ [
+ 0xa0, 0xbf, 0x6e, 0x1d, 0x18, 0x05, 0xfa, 0x54, 0x61, 0xed, 0xd6, 0x13, 0xc6,
+ 0xa9, 0x15, 0x92, 0xf0, 0xca, 0x57, 0x61, 0xa9, 0x06, 0x8e, 0x92, 0x0f, 0x01,
+ 0x0a, 0xd6, 0x0b, 0x86, 0x19, 0x17,
+ ],
+ [
+ 0x14, 0x06, 0x7b, 0x95, 0xe3, 0xc6, 0x9f, 0x9d, 0x37, 0xe8, 0x16, 0x83, 0xcd,
+ 0x27, 0x66, 0x21, 0x0e, 0x18, 0x88, 0x76, 0x82, 0x13, 0xdb, 0x94, 0xd5, 0x97,
+ 0x88, 0x02, 0x98, 0x4f, 0x05, 0x4f, 0xa2, 0x1b, 0x11, 0x11, 0xd0, 0x54, 0x3a,
+ 0x52, 0x4c, 0x3e, 0xaa, 0x03, 0x83, 0xea, 0xee, 0xd7,
+ ],
+ [
+ 0xf1, 0xbb, 0x54, 0x7f, 0xde, 0x14, 0x79, 0x3e, 0x99, 0x3b, 0x06, 0x02, 0xa3,
+ 0x32, 0x8c, 0x8e, 0x6c, 0xd5, 0xdd, 0x2e, 0xe3, 0xcb, 0xd8, 0x14, 0x0c, 0x43,
+ 0x37, 0x95, 0xa0, 0x4c, 0xa8, 0x27, 0x58, 0x7a, 0x48, 0x3f, 0xd7, 0xb9, 0x0b,
+ 0x8e, 0x28, 0x9b, 0x1c, 0x8d, 0xa6, 0xf4, 0x73, 0x75, 0x35, 0x9a, 0x2d, 0x8d,
+ 0x01, 0x83, 0xb1, 0x4a, 0x47, 0x90, 0x6a, 0xb6, 0xb3, 0x02, 0xc0, 0x29,
+ ]
+ ),
+ test_case!(
+ [0x09, 0x62, 0xe5, 0x5e, 0xd1,],
+ [
+ 0xe5, 0x12, 0x05, 0x77, 0xe0, 0x43, 0x43, 0x41, 0x29, 0xea, 0x5a, 0x04, 0x45,
+ 0xd1, 0xd2, 0xcc, 0x78, 0xd8, 0x25, 0xa9,
+ ],
+ [
+ 0x89, 0xa5, 0x0c, 0xd3, 0xda, 0xb7, 0x67, 0xbe, 0x05, 0xb7, 0xcb, 0xc7, 0xf6,
+ 0x07, 0xf0, 0x12, 0x86, 0x3d, 0x36, 0x4b, 0x04, 0x78, 0xda, 0x8e, 0x0f, 0x1d,
+ 0x61, 0x62, 0xab, 0x66, 0x72, 0x7f,
+ ],
+ [
+ 0xd1, 0x70, 0xe8, 0x76, 0xe9, 0x9b, 0x2b, 0x9d, 0x53, 0x24, 0x9d, 0x24, 0x65,
+ 0xab, 0x2e, 0x77, 0xe4, 0xbd, 0x8e, 0xcb, 0xa0, 0x0b, 0x03, 0xe8, 0xf0, 0x65,
+ 0x77, 0xff, 0xf9, 0x20, 0x14, 0xaa, 0xc5, 0x98, 0x7e, 0xd0, 0x3a, 0x93, 0x93,
+ 0x79, 0x13, 0x39, 0x6d, 0x78, 0xe8, 0x62, 0xf3, 0x47,
+ ],
+ [
+ 0xdf, 0x20, 0x2a, 0x4f, 0x13, 0xec, 0xa8, 0x01, 0x1d, 0xa3, 0xe6, 0x8a, 0x1e,
+ 0x1d, 0xf4, 0xf6, 0x6b, 0x70, 0x63, 0x1f, 0xbb, 0x2e, 0x1b, 0x1f, 0x46, 0x01,
+ 0xb6, 0xa2, 0x22, 0x90, 0x6a, 0x80, 0xe7, 0x10, 0xb7, 0xe0, 0xf6, 0xa2, 0xd6,
+ 0x76, 0x0b, 0xc3, 0xae, 0x0a, 0x90, 0xe3, 0xee, 0x39, 0xbb, 0x77, 0xad, 0x9d,
+ 0x81, 0x0a, 0xde, 0x8d, 0xbf, 0xea, 0x98, 0x88, 0xb9, 0xa2, 0xf4, 0x61,
+ ]
+ ),
+ test_case!(
+ [0xd9, 0xd4, 0xc3, 0x4b, 0x3a, 0xcb,],
+ [
+ 0x91, 0x62, 0xc5, 0xba, 0x27, 0xfa, 0x63, 0xe4, 0xec, 0x34, 0x37, 0xea, 0xd3,
+ 0x08, 0x06, 0xad, 0x0a, 0x19, 0x72, 0x7f,
+ ],
+ [
+ 0x5f, 0xd4, 0xc5, 0x4f, 0x7e, 0x6d, 0xca, 0x1e, 0x8f, 0x0c, 0x62, 0x08, 0x16,
+ 0xbf, 0x14, 0xd9, 0x7c, 0x1f, 0x16, 0x29, 0x5e, 0xaa, 0x08, 0x52, 0x59, 0xe9,
+ 0x6b, 0x1d, 0xe6, 0xe8, 0xea, 0x03,
+ ],
+ [
+ 0xb5, 0x6c, 0x7a, 0x32, 0xf2, 0xf8, 0x94, 0x8b, 0x7f, 0x35, 0xb8, 0x09, 0xec,
+ 0x99, 0x72, 0xd1, 0x58, 0x29, 0x69, 0xc9, 0x3c, 0xd8, 0x88, 0x8c, 0x06, 0xd5,
+ 0x7c, 0xf0, 0xee, 0x60, 0x7f, 0x91, 0x45, 0x99, 0x86, 0x31, 0x0a, 0xfa, 0x1c,
+ 0x1a, 0x3a, 0x09, 0x27, 0x0d, 0xbd, 0x90, 0xed, 0x28,
+ ],
+ [
+ 0x62, 0xa4, 0x1e, 0x8a, 0x8d, 0xe6, 0xb9, 0x9d, 0xce, 0xc6, 0x24, 0x7c, 0x3f,
+ 0xfc, 0x45, 0x94, 0x72, 0xdd, 0xdc, 0xdd, 0x94, 0xb8, 0x01, 0xa1, 0x02, 0x12,
+ 0xa9, 0x60, 0x6a, 0x10, 0x9b, 0xa6, 0xff, 0xaa, 0x83, 0x8f, 0x61, 0x1c, 0xc3,
+ 0x2d, 0xc9, 0xe2, 0xbc, 0xc2, 0x94, 0x80, 0x3f, 0x15, 0x23, 0xab, 0xa0, 0x59,
+ 0x59, 0x05, 0xf9, 0xc4, 0x50, 0xe6, 0xd3, 0x01, 0xb0, 0xee, 0x1c, 0x89,
+ ]
+ ),
+ test_case!(
+ [0x36, 0x72, 0xd4, 0x9a, 0x29, 0xbf, 0x1d,],
+ [
+ 0xc3, 0xb2, 0x4c, 0xfa, 0xeb, 0x2c, 0x76, 0x15, 0x94, 0xda, 0xb0, 0x10, 0x2f,
+ 0xa9, 0xbd, 0xad, 0x4b, 0x77, 0x04, 0xe1,
+ ],
+ [
+ 0x75, 0x6d, 0x7b, 0x06, 0x50, 0xdb, 0x5c, 0xc8, 0xa5, 0xdd, 0xd8, 0xf8, 0x77,
+ 0x35, 0x40, 0x9e, 0x7f, 0xd2, 0x39, 0x2b, 0x67, 0xcb, 0x38, 0x45, 0xb6, 0xc7,
+ 0xf3, 0x5b, 0xc1, 0x95, 0xc4, 0x53,
+ ],
+ [
+ 0x48, 0x86, 0x0a, 0xff, 0x63, 0x0b, 0x1c, 0x56, 0x50, 0x9f, 0x98, 0x03, 0xf0,
+ 0xb1, 0x5f, 0xca, 0x11, 0x05, 0xab, 0x38, 0x17, 0xd7, 0x27, 0x81, 0x01, 0x54,
+ 0x16, 0x95, 0x72, 0x3d, 0xba, 0x5f, 0x25, 0x42, 0xb6, 0x92, 0xf7, 0x8b, 0xf8,
+ 0xb8, 0xb2, 0x26, 0xe7, 0x4c, 0xf5, 0x4c, 0x6e, 0x74,
+ ],
+ [
+ 0xcc, 0xc4, 0x8c, 0x19, 0x96, 0xc1, 0xc4, 0x93, 0x99, 0x81, 0x3b, 0x0b, 0x2f,
+ 0x05, 0xd5, 0x5f, 0x8c, 0xa4, 0xf2, 0x27, 0x06, 0xd2, 0xa7, 0xdc, 0xb7, 0x7e,
+ 0xab, 0x14, 0xf7, 0x9c, 0x7e, 0x6e, 0xfc, 0x87, 0x9f, 0xd1, 0x17, 0x13, 0xa6,
+ 0xf6, 0xd8, 0x05, 0x22, 0x66, 0x7a, 0x35, 0xe7, 0x1f, 0x7a, 0xfc, 0x52, 0xf1,
+ 0x45, 0xb1, 0xab, 0x7f, 0x2b, 0x25, 0x64, 0xca, 0x8e, 0x19, 0x8b, 0x82,
+ ]
+ ),
+ test_case!(
+ [0x42, 0x2e, 0xa1, 0xe3, 0xf4, 0x36, 0x10, 0x7f,],
+ [
+ 0x30, 0xa1, 0x6c, 0x9c, 0xdd, 0xa3, 0xe5, 0xfc, 0x8f, 0x98, 0x50, 0xbc, 0xc4,
+ 0xe1, 0x74, 0x7d, 0x6e, 0x24, 0xd2, 0x8f,
+ ],
+ [
+ 0x19, 0xf4, 0xfb, 0xed, 0x7f, 0x6d, 0xb4, 0xb4, 0x89, 0x3c, 0xe3, 0x39, 0xa3,
+ 0x66, 0x8c, 0x5b, 0xf5, 0x3b, 0x12, 0xbd, 0xc6, 0x10, 0xd7, 0x24, 0x70, 0x75,
+ 0x43, 0xe2, 0xab, 0x1f, 0xf3, 0x90,
+ ],
+ [
+ 0x0c, 0x3a, 0xaa, 0x4f, 0x20, 0x7a, 0x15, 0x5f, 0x94, 0x54, 0x44, 0x77, 0x3c,
+ 0x2c, 0x65, 0x5a, 0xab, 0x09, 0x4b, 0xe8, 0xe5, 0xc9, 0x90, 0x3e, 0x9c, 0xe4,
+ 0x58, 0x7f, 0xc5, 0xfc, 0x17, 0x00, 0xad, 0xa8, 0x10, 0x68, 0xe5, 0x45, 0x4f,
+ 0xbd, 0x72, 0x86, 0x96, 0xd6, 0x24, 0x01, 0x80, 0x42,
+ ],
+ [
+ 0x49, 0x11, 0x12, 0xa6, 0x41, 0xa5, 0x21, 0x01, 0x17, 0x99, 0x9f, 0x47, 0xd9,
+ 0xc8, 0x7c, 0xce, 0x7d, 0xbc, 0x51, 0x1c, 0x0b, 0xf1, 0x1b, 0xdb, 0xc2, 0xce,
+ 0x3f, 0x11, 0x21, 0x58, 0x9b, 0xd9, 0xab, 0x02, 0x22, 0x23, 0x8c, 0x17, 0xb9,
+ 0x00, 0x98, 0x75, 0xa3, 0xba, 0x2a, 0xa7, 0x05, 0x34, 0xe0, 0x62, 0x63, 0x16,
+ 0x77, 0x8c, 0xb9, 0x4e, 0x9c, 0x31, 0x01, 0x1f, 0xa2, 0x9c, 0xd5, 0x75,
+ ]
+ ),
+ test_case!(
+ [0x0e, 0x12, 0x78, 0xd0, 0x02, 0x30, 0x0d, 0x41, 0x07,],
+ [
+ 0xd0, 0x60, 0x8e, 0x46, 0xde, 0xab, 0x56, 0x02, 0xf7, 0xaf, 0x62, 0x6d, 0xf7,
+ 0x37, 0x63, 0x87, 0xb1, 0x8c, 0x3c, 0xee,
+ ],
+ [
+ 0xb6, 0xf5, 0x6f, 0x8f, 0x3e, 0xef, 0x67, 0x41, 0x19, 0x93, 0x2f, 0x94, 0xe4,
+ 0xc1, 0x34, 0x9d, 0xa3, 0x2e, 0x22, 0x43, 0x7c, 0x5d, 0x8d, 0x36, 0xe1, 0x30,
+ 0xba, 0x23, 0x56, 0xe4, 0x17, 0xf8,
+ ],
+ [
+ 0x88, 0x1f, 0x55, 0x6b, 0xa1, 0xb7, 0x78, 0x57, 0x9c, 0x70, 0x20, 0x2a, 0x1c,
+ 0xb0, 0x7d, 0xfe, 0x50, 0x77, 0x5f, 0x1a, 0xef, 0x22, 0xa7, 0x19, 0xc7, 0xa4,
+ 0x20, 0xdb, 0x2a, 0x08, 0x5a, 0x19, 0x5d, 0x49, 0xd1, 0x7e, 0x62, 0x90, 0x3e,
+ 0x01, 0xd7, 0x8a, 0xb9, 0xc7, 0x78, 0x78, 0xac, 0xd3,
+ ],
+ [
+ 0x67, 0x50, 0xb1, 0x79, 0xc9, 0x99, 0x8e, 0x3e, 0xad, 0x7c, 0xdd, 0x1e, 0xaa,
+ 0xcc, 0x2c, 0xa6, 0xc7, 0x6d, 0x1d, 0x6c, 0x46, 0xeb, 0x42, 0x33, 0xda, 0x2e,
+ 0x41, 0xde, 0xf9, 0xcd, 0xb2, 0x20, 0xce, 0x0a, 0x6d, 0x4a, 0x9e, 0x0d, 0x77,
+ 0x1f, 0xab, 0xd2, 0x9d, 0xbc, 0x26, 0xc9, 0xbe, 0x9a, 0xe6, 0x61, 0x0a, 0xcf,
+ 0xac, 0x1d, 0x66, 0x02, 0x0a, 0x23, 0x29, 0xcc, 0x98, 0xff, 0x4c, 0x8e,
+ ]
+ ),
+ test_case!(
+ [0x05, 0x59, 0x9d, 0x46, 0x81, 0xbe, 0xd2, 0xec, 0x44, 0xd7,],
+ [
+ 0xfd, 0xe3, 0x78, 0xb4, 0x43, 0x36, 0xfa, 0xe4, 0xe2, 0x5e, 0x8f, 0x94, 0x72,
+ 0x6a, 0x6c, 0xe4, 0x01, 0x4f, 0x6e, 0x8a,
+ ],
+ [
+ 0x02, 0xfc, 0x28, 0x37, 0x4f, 0xc9, 0x8a, 0xa2, 0xa4, 0x71, 0x8f, 0x6f, 0x8e,
+ 0x0b, 0xa2, 0xa6, 0x95, 0x2d, 0x5f, 0x13, 0x33, 0x95, 0x24, 0x87, 0xcb, 0xc7,
+ 0x7b, 0xbe, 0xde, 0xa9, 0xc0, 0xf2,
+ ],
+ [
+ 0xeb, 0x42, 0x84, 0xeb, 0xc8, 0x15, 0x22, 0x7a, 0xaa, 0x0a, 0x4c, 0x0a, 0x12,
+ 0x54, 0x33, 0xea, 0xac, 0xfe, 0x53, 0x22, 0x1c, 0x5a, 0xdf, 0x60, 0x0e, 0x92,
+ 0x52, 0x25, 0xa7, 0x29, 0x0a, 0xcd, 0x0a, 0x88, 0x5e, 0xaa, 0xe0, 0x57, 0x94,
+ 0x2d, 0x66, 0xab, 0x27, 0x1f, 0x3e, 0xe1, 0xf2, 0xb2,
+ ],
+ [
+ 0x84, 0xa8, 0x86, 0x2e, 0xf9, 0x2f, 0x67, 0xe9, 0x43, 0xad, 0xdb, 0xce, 0x99,
+ 0x79, 0x2a, 0xf8, 0xe1, 0xd7, 0x13, 0x3a, 0x34, 0x57, 0xd1, 0x14, 0x90, 0xab,
+ 0x0f, 0x8a, 0x5f, 0x1d, 0x42, 0x6e, 0x8e, 0x63, 0xa1, 0x6d, 0x06, 0x5c, 0x7e,
+ 0xec, 0x93, 0x3b, 0x09, 0x6b, 0x71, 0x7d, 0x83, 0x23, 0xfe, 0x31, 0x2f, 0x03,
+ 0xda, 0x38, 0xdb, 0xf1, 0xb8, 0x20, 0x5a, 0x28, 0xef, 0x10, 0x52, 0x25,
+ ]
+ ),
+ test_case!(
+ [0xe1, 0x93, 0x50, 0x85, 0xba, 0x11, 0x74, 0xcc, 0x82, 0x4c, 0x82,],
+ [
+ 0x2b, 0xff, 0x1b, 0x64, 0x12, 0xb7, 0xdf, 0x5b, 0x9a, 0x95, 0x76, 0x53, 0xce,
+ 0x3f, 0x76, 0x41, 0xaa, 0x70, 0xaf, 0x2e,
+ ],
+ [
+ 0xce, 0xce, 0x12, 0xbf, 0x23, 0xc7, 0x0c, 0xc1, 0xd1, 0xb6, 0xed, 0x13, 0x0d,
+ 0x29, 0x0e, 0x6f, 0x8e, 0x86, 0x25, 0xfe, 0x78, 0x50, 0x70, 0xbf, 0x21, 0x6a,
+ 0xf2, 0xfc, 0xf2, 0x4c, 0x1e, 0x66,
+ ],
+ [
+ 0xc2, 0x88, 0x9a, 0x1e, 0x32, 0x4d, 0x0d, 0x1e, 0x29, 0xd9, 0x02, 0x58, 0x66,
+ 0x5c, 0x6e, 0xdf, 0x15, 0xb7, 0xcb, 0x6b, 0xda, 0x5a, 0x80, 0x34, 0xb2, 0xc2,
+ 0xa5, 0x17, 0x4a, 0xc6, 0x3b, 0x8a, 0x14, 0x48, 0x81, 0xa7, 0xc4, 0x80, 0x96,
+ 0xf7, 0xd4, 0x39, 0x81, 0x8f, 0x5e, 0xf2, 0x6f, 0x09,
+ ],
+ [
+ 0xec, 0x33, 0xa6, 0x67, 0xed, 0x23, 0xd9, 0x62, 0x87, 0xda, 0x83, 0xce, 0x02,
+ 0x56, 0x39, 0xfb, 0x0d, 0x7e, 0x79, 0x4a, 0x73, 0x51, 0x4c, 0x18, 0x15, 0xe8,
+ 0x14, 0x44, 0xa0, 0x54, 0x3b, 0x41, 0x5f, 0xf2, 0x32, 0x4b, 0x18, 0x0d, 0x64,
+ 0x6f, 0xe1, 0xe9, 0x0b, 0x4c, 0x47, 0xf0, 0xfb, 0xbc, 0xa4, 0x93, 0x69, 0x9d,
+ 0xa9, 0x4f, 0x97, 0x7e, 0x9a, 0x7a, 0x33, 0xe1, 0xce, 0x31, 0x85, 0x22,
+ ]
+ ),
+ test_case!(
+ [0x0b, 0xeb, 0xfe, 0xb8, 0x0b, 0xc3, 0x81, 0x3c, 0xa0, 0xd1, 0xe5, 0x18,],
+ [
+ 0x07, 0x10, 0xc0, 0x4f, 0x16, 0xe0, 0x09, 0x59, 0x8d, 0xe0, 0xd6, 0xf8, 0x11,
+ 0x84, 0x9a, 0x1b, 0xad, 0x4f, 0xc9, 0x7b,
+ ],
+ [
+ 0xaa, 0x79, 0x98, 0x67, 0xe9, 0xcf, 0xaf, 0x0e, 0x16, 0xb1, 0x4d, 0xe5, 0x9e,
+ 0x28, 0x93, 0x50, 0x3a, 0x15, 0x50, 0x64, 0x73, 0x40, 0x1a, 0x19, 0xfd, 0x2b,
+ 0xfb, 0x12, 0x07, 0x52, 0xa5, 0x7f,
+ ],
+ [
+ 0xa1, 0xe4, 0x82, 0x89, 0x8d, 0xa1, 0x8b, 0x44, 0x98, 0xa3, 0xf8, 0xab, 0x02,
+ 0x60, 0x28, 0x16, 0xd3, 0x32, 0x1b, 0xbd, 0xc4, 0xae, 0xc0, 0xd2, 0x90, 0xc6,
+ 0xa1, 0x12, 0xa1, 0xd2, 0x00, 0xac, 0x46, 0x42, 0xa2, 0x53, 0x5a, 0xb9, 0xf1,
+ 0x50, 0x80, 0x4c, 0xfa, 0xd7, 0xee, 0x36, 0xf9, 0x35,
+ ],
+ [
+ 0x3f, 0x4c, 0x3e, 0x2b, 0x3c, 0x99, 0xc8, 0x23, 0x38, 0x7d, 0xbf, 0xb6, 0xaf,
+ 0xe3, 0x23, 0xf1, 0x95, 0x1b, 0xa4, 0x04, 0x9e, 0x44, 0xe1, 0x74, 0x0a, 0x38,
+ 0x71, 0x58, 0xfd, 0xe1, 0xb7, 0x59, 0x1f, 0x64, 0x5d, 0x77, 0xe2, 0x51, 0x11,
+ 0x3e, 0xcc, 0x80, 0x11, 0x60, 0xa8, 0x2f, 0xe9, 0x98, 0x24, 0x45, 0x90, 0x55,
+ 0x55, 0x24, 0xb9, 0x4f, 0x24, 0x23, 0xc8, 0xbc, 0xf2, 0x3b, 0x28, 0x8b,
+ ]
+ ),
+ test_case!(
+ [0x7c, 0x10, 0xa4, 0x4b, 0xde, 0x62, 0x86, 0xe0, 0x97, 0x96, 0x88, 0x5e, 0x8c,],
+ [
+ 0xfa, 0xba, 0xd7, 0x84, 0xbf, 0x1b, 0x4c, 0xec, 0xaa, 0x27, 0x20, 0xa6, 0xda,
+ 0x43, 0xcb, 0x0b, 0x6d, 0xd1, 0xf6, 0xa9,
+ ],
+ [
+ 0x34, 0xbe, 0x8f, 0xde, 0x2a, 0x43, 0x29, 0x0f, 0x67, 0x85, 0xce, 0xb6, 0x91,
+ 0x8a, 0xcf, 0x86, 0xe5, 0x77, 0x6d, 0x33, 0x6e, 0xc1, 0xfd, 0x04, 0x6a, 0x5b,
+ 0x3f, 0x6b, 0x17, 0x50, 0x6d, 0x4a,
+ ],
+ [
+ 0xf4, 0x91, 0x8f, 0x35, 0x5d, 0xe9, 0x5a, 0xbc, 0xbc, 0xe8, 0x70, 0x00, 0xa1,
+ 0xbe, 0x36, 0x25, 0x13, 0x65, 0x31, 0xaa, 0xce, 0xe6, 0x73, 0xdf, 0x0f, 0xcc,
+ 0x29, 0x26, 0x6b, 0x92, 0x54, 0xa8, 0x20, 0x3c, 0xfa, 0x16, 0xfb, 0x3f, 0xda,
+ 0xde, 0x76, 0x1d, 0xcf, 0x44, 0x1d, 0xf2, 0xea, 0x61,
+ ],
+ [
+ 0x19, 0x19, 0xb9, 0xd2, 0xf6, 0x26, 0xb7, 0x48, 0x7a, 0x06, 0x29, 0xfa, 0x70,
+ 0xef, 0xa6, 0x45, 0x5e, 0x75, 0x33, 0xa2, 0x5d, 0xda, 0x56, 0x7b, 0x76, 0xde,
+ 0x29, 0x2f, 0x78, 0x61, 0x8f, 0xcf, 0x21, 0x1e, 0x90, 0x83, 0x59, 0x93, 0x1d,
+ 0xe2, 0x1d, 0xe3, 0x11, 0x00, 0x01, 0x7f, 0x9e, 0x13, 0xa1, 0x82, 0xc5, 0xa6,
+ 0x03, 0xbf, 0xc1, 0x82, 0x33, 0x3a, 0x60, 0x47, 0xe0, 0xca, 0xea, 0x41,
+ ]
+ ),
+ test_case!(
+ [
+ 0x08, 0x2f, 0x10, 0x32, 0x44, 0x7a, 0x54, 0x50, 0x09, 0x69, 0x4a, 0x29, 0x59,
+ 0x35,
+ ],
+ [
+ 0x8f, 0x57, 0x27, 0xba, 0x85, 0xbf, 0x1c, 0xab, 0x25, 0x10, 0x54, 0x57, 0x6e,
+ 0x57, 0xbe, 0x9d, 0x36, 0x00, 0x1b, 0xd5,
+ ],
+ [
+ 0x01, 0x8e, 0x47, 0xe3, 0xec, 0x99, 0x9b, 0xe9, 0xcc, 0xfa, 0xb5, 0xe2, 0x37,
+ 0x71, 0xeb, 0x01, 0xc8, 0x69, 0xc7, 0x70, 0xcd, 0x08, 0x39, 0x9e, 0x95, 0x65,
+ 0x61, 0x57, 0x20, 0x7c, 0x40, 0x5f,
+ ],
+ [
+ 0x95, 0xbe, 0xc6, 0x2a, 0xd0, 0x90, 0x88, 0xfe, 0x7c, 0x12, 0x75, 0x17, 0x65,
+ 0x04, 0xd4, 0x70, 0x50, 0x69, 0xda, 0x81, 0x0d, 0x00, 0x26, 0x80, 0x6d, 0x12,
+ 0x7b, 0xb7, 0x5b, 0x44, 0x00, 0x0b, 0x17, 0xc3, 0xcc, 0x7d, 0x42, 0x01, 0xae,
+ 0xd3, 0xa1, 0xa7, 0x52, 0xae, 0xf6, 0x35, 0xf8, 0x4c,
+ ],
+ [
+ 0x70, 0x28, 0x02, 0xf3, 0x9c, 0x2c, 0x0d, 0xb8, 0x04, 0x17, 0x6f, 0x20, 0x8c,
+ 0xb6, 0xa4, 0x69, 0xcf, 0x05, 0x80, 0x2d, 0x2e, 0xc7, 0x69, 0x94, 0xa7, 0x00,
+ 0xcf, 0xab, 0x42, 0x6f, 0x58, 0x2a, 0xec, 0x0c, 0x5e, 0x34, 0x50, 0x12, 0x68,
+ 0xdc, 0xbb, 0x30, 0x6b, 0x8a, 0xd8, 0x80, 0xfa, 0x15, 0x4e, 0x4b, 0x50, 0x5d,
+ 0xd2, 0x9c, 0x9b, 0x0e, 0xa7, 0xc8, 0x18, 0xe3, 0x1b, 0xf1, 0x2a, 0xfb,
+ ]
+ ),
+ test_case!(
+ [
+ 0x47, 0x0b, 0xfa, 0x80, 0xbd, 0x30, 0x29, 0xa8, 0x70, 0x39, 0x8d, 0xe8, 0x99,
+ 0xd7, 0x63,
+ ],
+ [
+ 0x35, 0x2c, 0x7f, 0xbf, 0xd0, 0x7a, 0xfa, 0xa7, 0xcb, 0x3a, 0xd2, 0x1d, 0xd7,
+ 0x34, 0x91, 0x5a, 0xb3, 0x7b, 0xbb, 0xb7,
+ ],
+ [
+ 0x9d, 0x9c, 0xb4, 0x3b, 0x4d, 0xc9, 0x96, 0xa1, 0x54, 0x06, 0xbd, 0x3d, 0x36,
+ 0xde, 0x3b, 0x84, 0x12, 0x19, 0x8b, 0x91, 0xe7, 0xf0, 0xf4, 0x71, 0x28, 0xb3,
+ 0x88, 0x9f, 0x84, 0x1b, 0x0d, 0x11,
+ ],
+ [
+ 0x06, 0x60, 0x85, 0x04, 0x64, 0x47, 0x81, 0x27, 0x39, 0x07, 0xbb, 0x46, 0xf0,
+ 0xb4, 0xab, 0x53, 0x36, 0x39, 0x4a, 0xc8, 0x9e, 0xe0, 0x47, 0x1c, 0xde, 0xb1,
+ 0x38, 0xb4, 0x00, 0xdc, 0x22, 0x17, 0xf1, 0x1c, 0x39, 0xab, 0x34, 0x5f, 0xf7,
+ 0xb5, 0xe6, 0x41, 0x3b, 0xcc, 0xcf, 0x5b, 0x3e, 0x2c,
+ ],
+ [
+ 0xea, 0x58, 0x8e, 0x22, 0x55, 0xc4, 0x2b, 0xe7, 0x56, 0x4d, 0x84, 0x00, 0x41,
+ 0xe1, 0x8b, 0xe2, 0xf0, 0xce, 0x32, 0xdd, 0x8a, 0x31, 0x4a, 0x68, 0x5e, 0x2d,
+ 0xeb, 0xfb, 0x99, 0x58, 0x8a, 0xa0, 0x29, 0xde, 0xe8, 0x0f, 0x16, 0xe6, 0x85,
+ 0x44, 0xbc, 0xc4, 0x0a, 0x8b, 0x06, 0xb3, 0x5b, 0x6d, 0xa3, 0xff, 0xa5, 0x61,
+ 0x0e, 0x26, 0x63, 0x43, 0xb1, 0xfd, 0x59, 0xd1, 0x3b, 0x44, 0xce, 0xbc,
+ ]
+ ),
+ test_case!(
+ [
+ 0x6b, 0xb7, 0xed, 0x62, 0x99, 0xab, 0x6b, 0xb3, 0x8c, 0xf4, 0xe1, 0x75, 0xc5,
+ 0x85, 0x46, 0xd3,
+ ],
+ [
+ 0xdc, 0x20, 0xf5, 0x00, 0x86, 0x0d, 0x4e, 0x0e, 0x1f, 0xf5, 0x9e, 0x8a, 0xed,
+ 0x93, 0x6b, 0xbd, 0x17, 0x43, 0xe7, 0x90,
+ ],
+ [
+ 0xea, 0xde, 0x1b, 0x2b, 0x62, 0xdf, 0x6d, 0xb4, 0x97, 0xbd, 0x1f, 0x08, 0xe6,
+ 0xbf, 0x0d, 0x76, 0x8c, 0xf1, 0x82, 0xff, 0x06, 0x0a, 0xb0, 0x03, 0xde, 0x73,
+ 0x4b, 0xac, 0xdf, 0x51, 0xa9, 0x19,
+ ],
+ [
+ 0xfb, 0x9e, 0x54, 0x2f, 0xca, 0x0d, 0x0e, 0x8a, 0x8b, 0x1a, 0x8d, 0x49, 0x38,
+ 0xe0, 0xf3, 0x3a, 0xcd, 0xe3, 0x45, 0x69, 0x54, 0xf3, 0x53, 0x81, 0x0d, 0x30,
+ 0xed, 0xbd, 0x87, 0x72, 0x76, 0xba, 0xd2, 0x8e, 0x6d, 0x40, 0x08, 0x16, 0x55,
+ 0xca, 0x7e, 0xa8, 0x82, 0x52, 0x6f, 0x43, 0xa2, 0x7f,
+ ],
+ [
+ 0x4a, 0xfc, 0xda, 0x87, 0x0d, 0x5c, 0x7b, 0xc8, 0x12, 0x07, 0x37, 0x46, 0x6f,
+ 0x41, 0x7f, 0xc0, 0xfb, 0xc3, 0xf9, 0x80, 0xe1, 0x0b, 0x08, 0x3b, 0x22, 0x02,
+ 0x10, 0x77, 0xe1, 0xb0, 0x4f, 0x93, 0xd5, 0x74, 0xd8, 0x87, 0x09, 0xf9, 0xa8,
+ 0xc6, 0xc3, 0x9b, 0x58, 0xd0, 0x3f, 0x86, 0x31, 0x39, 0x0e, 0xd4, 0x93, 0x9c,
+ 0xd8, 0xd0, 0x52, 0x7d, 0x9b, 0x8b, 0x1a, 0x03, 0x5e, 0x0e, 0x7f, 0xbe,
+ ]
+ ),
+ test_case!(
+ [
+ 0x94, 0x34, 0xb7, 0x7f, 0x7c, 0x62, 0xed, 0x3a, 0x7a, 0x25, 0xe9, 0x6c, 0x3f,
+ 0x14, 0xd3, 0x54, 0x38,
+ ],
+ [
+ 0x4d, 0x00, 0xf2, 0xad, 0x01, 0x19, 0x6b, 0xe3, 0xb1, 0x78, 0x7f, 0xf4, 0x3a,
+ 0x75, 0xf8, 0x81, 0xb5, 0x8e, 0x08, 0x64,
+ ],
+ [
+ 0x12, 0x35, 0x6c, 0xe3, 0xea, 0xe2, 0xa1, 0xdd, 0x08, 0x57, 0xa8, 0x44, 0x16,
+ 0xcd, 0xf5, 0x92, 0xe8, 0xfa, 0xee, 0xbb, 0x8c, 0xa3, 0x7c, 0x44, 0x84, 0x01,
+ 0x02, 0x10, 0x49, 0x01, 0xd2, 0x7e,
+ ],
+ [
+ 0x4d, 0xf6, 0xde, 0xc7, 0x48, 0x62, 0x4a, 0x16, 0x30, 0x37, 0x66, 0xc4, 0xd2,
+ 0x78, 0xf8, 0x00, 0x50, 0x3e, 0xf9, 0xed, 0x72, 0xdb, 0x54, 0x1b, 0x44, 0x92,
+ 0x75, 0xba, 0xa5, 0xfc, 0x6e, 0x7f, 0x5b, 0x58, 0x20, 0x46, 0x24, 0x26, 0x9a,
+ 0x70, 0xc2, 0x02, 0x6f, 0xb8, 0x0c, 0xb2, 0x60, 0xbc,
+ ],
+ [
+ 0xd1, 0xd9, 0x7b, 0xe8, 0x57, 0xbf, 0xe5, 0x0b, 0x49, 0xa9, 0xad, 0x70, 0xf2,
+ 0x64, 0xf1, 0x30, 0x70, 0x1e, 0x90, 0x52, 0x29, 0xc7, 0x0f, 0x4c, 0x1c, 0x33,
+ 0xb8, 0x53, 0x2d, 0x87, 0x46, 0xe9, 0x75, 0x35, 0x92, 0x3d, 0xf3, 0x5c, 0xa4,
+ 0x57, 0x3f, 0x64, 0xed, 0xf6, 0x2a, 0x1e, 0x1d, 0x6f, 0x64, 0xd0, 0x8a, 0x70,
+ 0xf2, 0xce, 0x59, 0xd6, 0x15, 0x32, 0x02, 0x74, 0x2c, 0x21, 0x56, 0xba,
+ ]
+ ),
+ test_case!(
+ [
+ 0xbb, 0x8d, 0x9c, 0x24, 0xa9, 0x07, 0x69, 0xbe, 0xc7, 0x08, 0x55, 0x22, 0x7e,
+ 0x3c, 0x09, 0xdd, 0x80, 0xce,
+ ],
+ [
+ 0x11, 0x17, 0x92, 0xb5, 0x66, 0x86, 0xa4, 0x2a, 0xb8, 0x90, 0x20, 0x09, 0x3d,
+ 0x08, 0x5d, 0xbb, 0x3d, 0x46, 0xa5, 0x84,
+ ],
+ [
+ 0x1f, 0xe8, 0x59, 0x35, 0x94, 0xc9, 0xf7, 0x24, 0xf8, 0xa4, 0xf1, 0xb0, 0xe1,
+ 0xd8, 0x38, 0x18, 0xa3, 0xfd, 0x3a, 0xc2, 0xfa, 0xa9, 0xc7, 0xa2, 0x8b, 0x8f,
+ 0x6d, 0x79, 0x26, 0xd0, 0x8a, 0x28,
+ ],
+ [
+ 0x9d, 0xf7, 0x08, 0x13, 0x48, 0xe3, 0x82, 0xc7, 0xd3, 0x52, 0xf7, 0x07, 0xa9,
+ 0x83, 0xe9, 0xf7, 0xa2, 0xdd, 0x23, 0xbe, 0x38, 0x6f, 0x99, 0x4b, 0x50, 0x20,
+ 0x73, 0x65, 0x45, 0x10, 0x6e, 0xa6, 0x64, 0xbd, 0x48, 0x3d, 0x10, 0x59, 0x62,
+ 0x68, 0xcf, 0x0c, 0xee, 0x49, 0x2b, 0x1a, 0x62, 0x87,
+ ],
+ [
+ 0x26, 0xca, 0x1b, 0x5b, 0xdc, 0x1a, 0xc3, 0xfc, 0xb5, 0x1c, 0x83, 0xbc, 0xfe,
+ 0xc4, 0x2e, 0xd2, 0xbb, 0x32, 0xc8, 0xc7, 0x09, 0x42, 0xf2, 0xf0, 0xe8, 0xd3,
+ 0x5c, 0xb5, 0xe5, 0x6d, 0xe3, 0x56, 0x1c, 0xf3, 0x8f, 0x94, 0x03, 0xaf, 0x20,
+ 0x60, 0xb6, 0xe1, 0xed, 0x49, 0xb8, 0x07, 0x16, 0x73, 0x2d, 0xd9, 0x19, 0x16,
+ 0x53, 0x4d, 0x4e, 0xc1, 0xb1, 0x91, 0xe4, 0xec, 0x60, 0x09, 0xfc, 0x80,
+ ]
+ ),
+ test_case!(
+ [
+ 0xfa, 0x82, 0x9f, 0x49, 0x26, 0xce, 0x44, 0x75, 0x8f, 0x81, 0xb3, 0x37, 0x88,
+ 0xbd, 0x0b, 0x1b, 0xed, 0xe3, 0xcc,
+ ],
+ [
+ 0x51, 0xfd, 0xe2, 0x78, 0x46, 0x97, 0xf3, 0xe1, 0x23, 0x2b, 0x6f, 0x83, 0x79,
+ 0x32, 0x7c, 0x09, 0x03, 0x8c, 0x32, 0x00,
+ ],
+ [
+ 0x73, 0xd6, 0x8e, 0xa8, 0x5d, 0x14, 0xf7, 0x06, 0x2d, 0x80, 0xb9, 0xa5, 0x16,
+ 0x68, 0x26, 0x31, 0x45, 0x10, 0xa1, 0xfe, 0xc4, 0x98, 0xda, 0x05, 0x15, 0xae,
+ 0xd7, 0xcd, 0x9d, 0x4c, 0xe7, 0x2b,
+ ],
+ [
+ 0xf4, 0x16, 0x61, 0x0c, 0xce, 0xfd, 0x2f, 0x7c, 0x5c, 0xd9, 0x00, 0x21, 0xe3,
+ 0x8e, 0x50, 0x81, 0x16, 0x62, 0x34, 0x5b, 0x6e, 0x84, 0x87, 0x29, 0x0b, 0x5f,
+ 0xf1, 0x6a, 0x08, 0x4f, 0x6e, 0xff, 0x45, 0xd5, 0x73, 0xdc, 0x38, 0xf3, 0x47,
+ 0x52, 0x44, 0x47, 0x0b, 0x49, 0x46, 0xb1, 0x5c, 0x5d,
+ ],
+ [
+ 0x71, 0xb3, 0x7e, 0xd8, 0x8a, 0x54, 0xba, 0xd0, 0xda, 0xff, 0xb1, 0x5e, 0xb5,
+ 0xef, 0x6b, 0x5f, 0xd0, 0x23, 0xf0, 0xb9, 0xab, 0xb8, 0xeb, 0x2a, 0xd2, 0xea,
+ 0xd0, 0xed, 0x3f, 0xde, 0x2c, 0x2c, 0x7a, 0x32, 0x32, 0xe3, 0x5c, 0x30, 0x7c,
+ 0xd7, 0xaa, 0x1f, 0x45, 0xb9, 0xaf, 0xbe, 0x42, 0x53, 0x79, 0xac, 0xb6, 0xda,
+ 0x10, 0x06, 0x62, 0x3b, 0x69, 0xc1, 0xb2, 0x98, 0x96, 0x24, 0xc3, 0xda,
+ ]
+ ),
+ test_case!(
+ [
+ 0x04, 0x9a, 0x7c, 0x85, 0x56, 0xb5, 0x4d, 0x57, 0xf2, 0x72, 0x30, 0xa8, 0x88,
+ 0x1f, 0xa7, 0x71, 0x66, 0xe8, 0x36, 0xd0,
+ ],
+ [
+ 0xb7, 0x7b, 0xbe, 0x98, 0xe8, 0x29, 0x8b, 0xda, 0xb3, 0x89, 0x78, 0x6f, 0xdf,
+ 0xf0, 0x5a, 0xf4, 0x45, 0x8f, 0x33, 0x9a,
+ ],
+ [
+ 0xf6, 0xfd, 0x72, 0xb8, 0x43, 0x14, 0xe0, 0xf6, 0xb2, 0x41, 0x5b, 0x3b, 0x26,
+ 0x69, 0xa6, 0x97, 0x06, 0xd7, 0x81, 0x79, 0x9b, 0xe0, 0x94, 0xb5, 0x39, 0xde,
+ 0x6b, 0x41, 0xbc, 0xc6, 0xe2, 0x18,
+ ],
+ [
+ 0xb9, 0x6e, 0xfd, 0x82, 0xec, 0x46, 0x8b, 0xb4, 0xa0, 0x6f, 0xc3, 0x41, 0x29,
+ 0x84, 0x19, 0x79, 0xd5, 0x64, 0xcc, 0x76, 0x51, 0x0f, 0xbf, 0x9a, 0x65, 0x1d,
+ 0x4c, 0x8f, 0x81, 0xd8, 0xf2, 0x2d, 0x24, 0x57, 0x22, 0x94, 0xef, 0x5f, 0x71,
+ 0x99, 0x46, 0xf2, 0x57, 0x83, 0x5b, 0xf4, 0x72, 0x0e,
+ ],
+ [
+ 0x01, 0x3a, 0x64, 0x78, 0xbb, 0x6f, 0x05, 0xbc, 0x0e, 0x70, 0x70, 0x10, 0x13,
+ 0xc8, 0xa2, 0x7d, 0xcf, 0xd4, 0xa7, 0x3f, 0xaf, 0x14, 0xab, 0x61, 0x63, 0x03,
+ 0x4b, 0xd0, 0xed, 0xbb, 0x73, 0x59, 0x43, 0xaf, 0x2f, 0xa7, 0x45, 0x10, 0xfe,
+ 0x62, 0x10, 0xa4, 0x02, 0xd5, 0x0e, 0x1a, 0x85, 0x61, 0xca, 0xaa, 0xd4, 0xd4,
+ 0xa9, 0x93, 0x91, 0xe2, 0x54, 0x6d, 0x3c, 0x1b, 0x8b, 0xa0, 0x4d, 0x88,
+ ]
+ ),
+ test_case!(
+ [
+ 0x2b, 0x7f, 0x18, 0x78, 0xc0, 0x08, 0x39, 0x2c, 0x83, 0x9e, 0x57, 0xb6, 0x5a,
+ 0xd4, 0x69, 0x13, 0xfa, 0xfe, 0x51, 0xfd, 0xa8,
+ ],
+ [
+ 0xc5, 0xa1, 0xb1, 0x21, 0x81, 0xac, 0xa2, 0x29, 0x85, 0x8a, 0x00, 0x8f, 0xf0,
+ 0x35, 0x1d, 0xca, 0x9e, 0x27, 0x62, 0x04,
+ ],
+ [
+ 0xe0, 0xfe, 0x5e, 0x18, 0xc5, 0x21, 0x79, 0x4b, 0xae, 0x79, 0x7d, 0x29, 0x71,
+ 0xe6, 0xfb, 0x14, 0xb5, 0xe1, 0x6f, 0xa2, 0xc3, 0xa3, 0x07, 0x66, 0x32, 0xad,
+ 0x76, 0x23, 0x24, 0xbe, 0x1b, 0xb6,
+ ],
+ [
+ 0xc1, 0x4b, 0x60, 0x9c, 0x52, 0x4e, 0x4d, 0xa3, 0xe4, 0x4d, 0x74, 0x1f, 0xee,
+ 0xc7, 0xa0, 0x5b, 0xa7, 0xdc, 0x79, 0x90, 0x41, 0x48, 0x4e, 0xe8, 0x7f, 0xeb,
+ 0x53, 0x28, 0x27, 0xd0, 0x59, 0x96, 0xc1, 0x3f, 0xd6, 0xac, 0x1e, 0x23, 0x51,
+ 0xc0, 0x8b, 0x6e, 0xdb, 0x76, 0xea, 0xdd, 0x9f, 0xfa,
+ ],
+ [
+ 0xf0, 0x42, 0x10, 0x13, 0x4d, 0x66, 0xbc, 0x3f, 0x1c, 0x0b, 0xfc, 0x57, 0x8f,
+ 0x75, 0x7c, 0x6b, 0xad, 0xd4, 0xae, 0x65, 0xf7, 0x17, 0x31, 0xf9, 0xdc, 0x62,
+ 0xe3, 0x26, 0xef, 0x60, 0x1a, 0x06, 0x6f, 0xe2, 0xa1, 0x9f, 0x61, 0xd8, 0x70,
+ 0xfe, 0x50, 0x4d, 0x02, 0x32, 0xea, 0xfc, 0x9c, 0x0c, 0x7f, 0x87, 0x4a, 0x77,
+ 0xcd, 0x70, 0xa4, 0x28, 0x67, 0x2e, 0x3e, 0xaf, 0x30, 0x3d, 0x58, 0x11,
+ ]
+ ),
+ test_case!(
+ [
+ 0x1a, 0xc9, 0x93, 0x29, 0xa1, 0x42, 0xb5, 0x17, 0xd2, 0xa3, 0xa2, 0x06, 0xf6,
+ 0x19, 0xdb, 0xea, 0x52, 0x05, 0xd8, 0x3c, 0x60, 0xdb,
+ ],
+ [
+ 0xce, 0xca, 0xaa, 0xff, 0xe6, 0x55, 0xa2, 0xfb, 0xb3, 0x4f, 0xf4, 0x2a, 0xef,
+ 0x27, 0xf3, 0x63, 0x57, 0x46, 0x4e, 0xac,
+ ],
+ [
+ 0x12, 0x1f, 0x90, 0x95, 0xe8, 0xdb, 0x52, 0x4a, 0x66, 0xe2, 0x9d, 0xe9, 0x03,
+ 0xc3, 0x33, 0x15, 0x7a, 0x63, 0x54, 0x70, 0x9e, 0x0a, 0x18, 0x1c, 0x61, 0x00,
+ 0x36, 0xd5, 0xb0, 0x9a, 0xbe, 0xef,
+ ],
+ [
+ 0x44, 0x82, 0xd1, 0xd3, 0x7a, 0xd7, 0xf0, 0xff, 0x34, 0xcb, 0x20, 0xb7, 0x51,
+ 0x5f, 0x52, 0xf5, 0xd8, 0xb1, 0x2b, 0xae, 0xc4, 0x28, 0x3d, 0x2d, 0xa3, 0x7b,
+ 0x0c, 0x91, 0x14, 0x41, 0x62, 0x16, 0x02, 0x02, 0x58, 0x4e, 0x64, 0xea, 0xce,
+ 0x99, 0x14, 0xe8, 0x6a, 0x66, 0x24, 0x68, 0x78, 0xf5,
+ ],
+ [
+ 0x3a, 0x39, 0x8a, 0x5e, 0xdd, 0x27, 0xca, 0xda, 0x88, 0x19, 0x6e, 0xae, 0xb3,
+ 0x7d, 0x11, 0x27, 0x3e, 0xa2, 0x1b, 0x13, 0x56, 0x69, 0x09, 0x7a, 0x77, 0x01,
+ 0xf5, 0xb7, 0x4d, 0xfa, 0x79, 0xb6, 0xfa, 0x77, 0x00, 0x15, 0x8f, 0x2c, 0xaf,
+ 0xd8, 0xee, 0x91, 0xed, 0xd5, 0x54, 0x7d, 0x71, 0x22, 0xe9, 0x23, 0x84, 0x22,
+ 0x0c, 0xc0, 0xca, 0xcd, 0xf7, 0x9e, 0xc1, 0xeb, 0xdd, 0xf9, 0xfe, 0xcf,
+ ]
+ ),
+ test_case!(
+ [
+ 0xde, 0x2b, 0x68, 0x04, 0xee, 0xb5, 0x4e, 0xd0, 0xca, 0x2f, 0x2c, 0x6a, 0x88,
+ 0x75, 0x67, 0xb4, 0x7a, 0x17, 0x72, 0xf3, 0xcf, 0x0d, 0x51,
+ ],
+ [
+ 0x3e, 0x2f, 0x15, 0x9d, 0x6a, 0x62, 0x11, 0x5f, 0x09, 0x38, 0x1a, 0x0c, 0x5e,
+ 0x61, 0xac, 0xac, 0x48, 0xeb, 0x65, 0x0c,
+ ],
+ [
+ 0xde, 0x73, 0x4e, 0xd5, 0x73, 0xe0, 0x9a, 0x51, 0x52, 0x68, 0x9b, 0x25, 0x20,
+ 0x05, 0x48, 0x68, 0xb6, 0xb1, 0x38, 0x7f, 0x51, 0x0b, 0x01, 0x2b, 0x1e, 0x69,
+ 0x42, 0x3e, 0x95, 0x4c, 0x69, 0x20,
+ ],
+ [
+ 0xd2, 0x28, 0x8b, 0x91, 0x5c, 0x87, 0xe5, 0xb3, 0xc2, 0x4b, 0x4b, 0x87, 0x0f,
+ 0x5a, 0x97, 0xbf, 0xbb, 0xee, 0xd0, 0x23, 0x2c, 0x19, 0x79, 0x88, 0x96, 0x18,
+ 0x02, 0x55, 0x21, 0x45, 0x73, 0x5f, 0x07, 0xe6, 0x21, 0xcb, 0xb3, 0x1e, 0xd2,
+ 0x88, 0x5d, 0xc2, 0x3c, 0x5a, 0x0d, 0xe7, 0x43, 0x4a,
+ ],
+ [
+ 0x04, 0x86, 0x15, 0x1d, 0x60, 0x85, 0xab, 0x87, 0x43, 0x83, 0x14, 0xcb, 0xde,
+ 0xe7, 0x69, 0xe5, 0x3a, 0x26, 0xeb, 0xd6, 0x9e, 0x29, 0x97, 0x79, 0xda, 0x38,
+ 0xa5, 0x02, 0xd3, 0xa2, 0x99, 0x66, 0xc0, 0x35, 0x62, 0xd7, 0xbd, 0x17, 0xf5,
+ 0xf0, 0x65, 0xeb, 0x7b, 0x3a, 0x74, 0x8d, 0x4e, 0xf7, 0xf1, 0xe1, 0x38, 0x4b,
+ 0xe5, 0x1f, 0x56, 0x20, 0x12, 0x89, 0xca, 0xb7, 0xc6, 0x6a, 0x4b, 0xdd,
+ ]
+ ),
+ test_case!(
+ [
+ 0xc3, 0xe8, 0x8b, 0x6d, 0x2e, 0x27, 0x45, 0x26, 0x68, 0xa8, 0xe5, 0x0f, 0x22,
+ 0xcd, 0xbd, 0xef, 0xc8, 0x00, 0x0e, 0x5d, 0x76, 0xdc, 0x1d, 0x2e,
+ ],
+ [
+ 0xd2, 0xd9, 0x86, 0x45, 0xf8, 0x63, 0xe8, 0x78, 0xaa, 0x4f, 0xf2, 0x62, 0x30,
+ 0x4f, 0xe3, 0xb5, 0xb8, 0xc4, 0xb4, 0xd6,
+ ],
+ [
+ 0x74, 0x86, 0x51, 0x31, 0xfd, 0x56, 0xff, 0x91, 0x3e, 0x71, 0xaa, 0x75, 0x2d,
+ 0xe4, 0x68, 0xed, 0x7b, 0x62, 0xbf, 0xc2, 0x02, 0x97, 0x17, 0xc5, 0xdc, 0x21,
+ 0xe6, 0x91, 0x4e, 0x71, 0xd5, 0xd9,
+ ],
+ [
+ 0x23, 0x2f, 0x22, 0x48, 0x72, 0xf2, 0xe3, 0x2f, 0xfd, 0x48, 0x9b, 0x06, 0xc7,
+ 0x14, 0xcd, 0xc6, 0x78, 0x7e, 0x3a, 0x6e, 0x85, 0xb5, 0xa3, 0xc6, 0x0e, 0x45,
+ 0x56, 0x42, 0xe4, 0xea, 0x1c, 0x0d, 0xa9, 0x62, 0xca, 0xe8, 0xb8, 0xe9, 0x01,
+ 0x33, 0x70, 0xd5, 0xfe, 0x90, 0x38, 0x6f, 0x9b, 0x7b,
+ ],
+ [
+ 0x07, 0x26, 0x97, 0x53, 0xaf, 0x2e, 0xa9, 0x16, 0xa0, 0xbf, 0xcd, 0x43, 0xe4,
+ 0x21, 0xe0, 0x7d, 0x10, 0xde, 0x71, 0xb2, 0x74, 0xf0, 0x91, 0x57, 0x3a, 0xe9,
+ 0x1a, 0x1f, 0xdf, 0x8c, 0x83, 0xb2, 0xed, 0xa0, 0x79, 0xcc, 0xcc, 0x31, 0x5b,
+ 0x78, 0xfa, 0x69, 0xc2, 0x5d, 0xd0, 0x0c, 0x9f, 0x1e, 0x75, 0x6f, 0x08, 0x86,
+ 0x06, 0x1e, 0xee, 0x95, 0x0c, 0xe5, 0x56, 0x2e, 0xe6, 0xad, 0x70, 0xe9,
+ ]
+ ),
+ test_case!(
+ [
+ 0x23, 0xbb, 0x9b, 0x96, 0x20, 0xd0, 0x03, 0xdd, 0xba, 0x97, 0x99, 0x75, 0xcd,
+ 0x8a, 0x71, 0x53, 0x03, 0x03, 0xd7, 0x55, 0xec, 0x93, 0xd1, 0xed, 0xf5,
+ ],
+ [
+ 0xbd, 0xc8, 0x6d, 0x60, 0xb5, 0xfb, 0x1c, 0xc4, 0x07, 0xbe, 0x68, 0x97, 0x51,
+ 0x1a, 0x2f, 0xe1, 0xd9, 0x57, 0x0c, 0xf2,
+ ],
+ [
+ 0xc8, 0xcd, 0xf7, 0xfa, 0xdd, 0x6e, 0x85, 0x9d, 0xd0, 0x39, 0x74, 0x3e, 0x4c,
+ 0xba, 0x12, 0xe7, 0x7b, 0x90, 0x81, 0xf3, 0xf3, 0x03, 0xb7, 0x37, 0x90, 0x28,
+ 0xa3, 0x6d, 0x8f, 0x57, 0xe1, 0x4b,
+ ],
+ [
+ 0x15, 0x25, 0x48, 0x5e, 0x54, 0xe3, 0x35, 0xbc, 0x5f, 0x44, 0xf5, 0xa9, 0x09,
+ 0x75, 0xc1, 0xca, 0xfb, 0x30, 0x64, 0x19, 0x53, 0xfa, 0x90, 0x95, 0xad, 0xd3,
+ 0xf4, 0xe0, 0x5e, 0x36, 0x12, 0x38, 0xd2, 0x26, 0x30, 0x90, 0xd7, 0xe3, 0x62,
+ 0x21, 0xc9, 0xd2, 0x3b, 0xa1, 0x9c, 0xaa, 0x84, 0x4e,
+ ],
+ [
+ 0x7a, 0xde, 0x43, 0xe8, 0x4c, 0x39, 0x7c, 0xa9, 0x22, 0x0f, 0x61, 0x2b, 0x93,
+ 0xa8, 0x81, 0x9f, 0x01, 0x24, 0x7d, 0x16, 0x6f, 0xf1, 0x24, 0x7d, 0x07, 0x85,
+ 0x99, 0x79, 0x66, 0x44, 0x6b, 0x94, 0xfe, 0x02, 0x14, 0x3c, 0x1f, 0xa3, 0xe2,
+ 0xf4, 0x05, 0x06, 0x24, 0x91, 0x1f, 0xf0, 0x8e, 0x88, 0xbb, 0xd9, 0x2a, 0x5c,
+ 0x69, 0x77, 0x1b, 0x66, 0xc5, 0x81, 0x4e, 0xb9, 0x1d, 0xe0, 0x92, 0xba,
+ ]
+ ),
+ test_case!(
+ [
+ 0xa6, 0x81, 0x05, 0xec, 0x7a, 0x50, 0xe6, 0xa5, 0x20, 0x76, 0xb1, 0x03, 0x13,
+ 0x33, 0x5a, 0xe1, 0x63, 0xf3, 0xc9, 0x65, 0x45, 0x2b, 0x5f, 0x69, 0xa3, 0xf3,
+ ],
+ [
+ 0x4c, 0xe4, 0xd1, 0x65, 0xb1, 0xfc, 0x1f, 0x52, 0x62, 0xe6, 0xad, 0xf6, 0x2b,
+ 0xdf, 0x99, 0xa6, 0xdc, 0x2d, 0x21, 0xa0,
+ ],
+ [
+ 0xcd, 0x86, 0x39, 0x09, 0x7a, 0xeb, 0x72, 0x76, 0x3a, 0x65, 0xdf, 0xd6, 0xa6,
+ 0x52, 0x84, 0x1a, 0xdc, 0xae, 0x19, 0x0c, 0x3f, 0xfd, 0xfe, 0x6c, 0xd0, 0x06,
+ 0x0e, 0x59, 0xb5, 0x74, 0x5b, 0x48,
+ ],
+ [
+ 0x01, 0xd2, 0xf0, 0x74, 0xf1, 0x5c, 0xf4, 0xa9, 0xda, 0x4a, 0xb2, 0xa2, 0xd3,
+ 0x3f, 0xdc, 0xb0, 0xe2, 0xc9, 0x79, 0xfc, 0xb0, 0x4d, 0x9d, 0x3d, 0xa2, 0x26,
+ 0xe7, 0xec, 0x32, 0x5b, 0x6a, 0x30, 0xf7, 0xd7, 0xda, 0xc4, 0xe4, 0x19, 0x3a,
+ 0x88, 0x18, 0x7a, 0x13, 0x4a, 0x15, 0x74, 0x90, 0xd4,
+ ],
+ [
+ 0x5d, 0x66, 0xfe, 0x48, 0x23, 0x96, 0x2d, 0x0e, 0x37, 0x43, 0xe3, 0x35, 0x35,
+ 0x33, 0x7a, 0x48, 0xbb, 0x12, 0x5c, 0x2f, 0x95, 0x9b, 0xf5, 0xa9, 0xf1, 0x64,
+ 0x84, 0x20, 0x86, 0xa3, 0x5b, 0x32, 0x18, 0x01, 0x0c, 0x8d, 0xfa, 0xbc, 0xd2,
+ 0x85, 0x67, 0x8a, 0xd7, 0xaf, 0x79, 0xab, 0xb0, 0x21, 0x10, 0x1b, 0x64, 0xb8,
+ 0xf4, 0xb2, 0x84, 0xf2, 0x11, 0xc3, 0xc0, 0x03, 0x75, 0x72, 0x4a, 0xf2,
+ ]
+ ),
+ test_case!(
+ [
+ 0x90, 0xd3, 0x1b, 0xfa, 0x1f, 0x19, 0xb6, 0x8b, 0x66, 0xc3, 0x3e, 0x86, 0x34,
+ 0x27, 0x02, 0x8b, 0x2e, 0x39, 0xb0, 0x3c, 0xab, 0xdd, 0x27, 0xc5, 0x89, 0x84,
+ 0xc5,
+ ],
+ [
+ 0x93, 0x6d, 0x2e, 0x14, 0xee, 0x14, 0x4f, 0x5e, 0xdb, 0xbc, 0xc8, 0x65, 0x33,
+ 0xa9, 0x24, 0x6a, 0x73, 0xa7, 0x52, 0x31,
+ ],
+ [
+ 0xcc, 0x4f, 0xd9, 0xb6, 0x04, 0xcc, 0xd7, 0x1b, 0xc9, 0xba, 0x5a, 0xf9, 0x97,
+ 0x0f, 0x87, 0x20, 0x64, 0xe3, 0xed, 0x02, 0xa6, 0x65, 0xb2, 0x90, 0x43, 0x62,
+ 0xd1, 0x56, 0xa4, 0xe3, 0x25, 0x62,
+ ],
+ [
+ 0x13, 0xe3, 0xee, 0x68, 0x88, 0xa7, 0x91, 0xa7, 0xfd, 0x37, 0x6f, 0xdb, 0xac,
+ 0x6c, 0x65, 0xaf, 0x29, 0x77, 0xc8, 0x29, 0x6b, 0xf4, 0x20, 0xee, 0x0c, 0x51,
+ 0x2b, 0x6f, 0x10, 0xfc, 0x18, 0x5a, 0x77, 0x8b, 0xcc, 0x22, 0xbc, 0x40, 0x89,
+ 0x89, 0x05, 0x22, 0x4e, 0xfd, 0x3b, 0x03, 0x0b, 0x0d,
+ ],
+ [
+ 0x99, 0xac, 0x48, 0x23, 0xa4, 0xeb, 0x91, 0xf0, 0x5a, 0x55, 0x59, 0x91, 0x99,
+ 0xfc, 0x12, 0xcd, 0xe0, 0xb0, 0x98, 0x36, 0xad, 0x20, 0x28, 0x91, 0x0b, 0x13,
+ 0x18, 0x34, 0xa0, 0xe9, 0x28, 0xf8, 0x8a, 0xea, 0x7e, 0xbf, 0xe6, 0xea, 0x0a,
+ 0x16, 0xc6, 0xe1, 0x4a, 0xfa, 0x31, 0x00, 0x8f, 0xb8, 0x50, 0x81, 0x1b, 0xfa,
+ 0x7a, 0x9a, 0xaf, 0x10, 0x82, 0xfe, 0x2d, 0x84, 0xb4, 0x43, 0xac, 0x6c,
+ ]
+ ),
+ test_case!(
+ [
+ 0x20, 0x2f, 0xaf, 0x9a, 0x58, 0x7b, 0x45, 0xf0, 0x8b, 0xab, 0xe6, 0x9a, 0x9a,
+ 0xe8, 0xfe, 0xcc, 0x8d, 0xe7, 0xf6, 0xe5, 0x43, 0xc7, 0xef, 0xe2, 0x86, 0x0d,
+ 0x45, 0x0a,
+ ],
+ [
+ 0x85, 0xd9, 0xed, 0x98, 0x63, 0x2c, 0xcd, 0x79, 0x16, 0xc5, 0xa4, 0x7e, 0xb7,
+ 0x86, 0x37, 0x44, 0xc2, 0x41, 0xfc, 0xba,
+ ],
+ [
+ 0x18, 0x9e, 0x9a, 0x1a, 0xa8, 0x85, 0xfa, 0x04, 0xae, 0x0a, 0x92, 0x4f, 0xf9,
+ 0xfa, 0x56, 0xda, 0x74, 0x86, 0xa0, 0x61, 0x6a, 0x5f, 0x64, 0x73, 0x97, 0x27,
+ 0x1a, 0x24, 0xbb, 0xd9, 0x53, 0x29,
+ ],
+ [
+ 0x20, 0x6d, 0xaa, 0x85, 0xcb, 0xd3, 0x98, 0x25, 0xdb, 0xd2, 0x3b, 0xff, 0xbf,
+ 0xce, 0x2e, 0xce, 0x74, 0xf7, 0x4d, 0xdb, 0xfc, 0x4a, 0x7d, 0x1a, 0xd8, 0x56,
+ 0xc0, 0xe0, 0x58, 0x90, 0x61, 0x9d, 0x62, 0x72, 0x08, 0xab, 0x57, 0x3d, 0xef,
+ 0xab, 0xf6, 0x86, 0x59, 0xf0, 0xe7, 0xec, 0xe4, 0x0a,
+ ],
+ [
+ 0x23, 0x50, 0x5d, 0xd0, 0x52, 0xd7, 0xd8, 0xea, 0x72, 0xec, 0xe0, 0x81, 0xc0,
+ 0xba, 0x48, 0xdf, 0xe6, 0xdc, 0x3c, 0xf6, 0xb5, 0x46, 0x95, 0x8f, 0x06, 0xa4,
+ 0x2e, 0x17, 0x67, 0x1a, 0x12, 0x2a, 0xdd, 0xbc, 0xf2, 0x81, 0xf4, 0x72, 0xa5,
+ 0x24, 0x0e, 0xb6, 0x2d, 0x57, 0x9f, 0xdc, 0xcc, 0xd6, 0xa0, 0xd6, 0xe4, 0x94,
+ 0xbe, 0x4e, 0x85, 0xf3, 0xac, 0x7f, 0xfd, 0xfe, 0x3e, 0xf7, 0x83, 0x9d,
+ ]
+ ),
+ test_case!(
+ [
+ 0xe2, 0xaf, 0x9b, 0x6b, 0x3c, 0x12, 0x91, 0x6c, 0xd5, 0x1a, 0xd1, 0xa7, 0x0b,
+ 0x36, 0x4a, 0x56, 0x70, 0x90, 0xee, 0xa9, 0xaa, 0x5a, 0xf2, 0x45, 0x62, 0x03,
+ 0x1c, 0x46, 0x10,
+ ],
+ [
+ 0xa2, 0xce, 0xfe, 0x9b, 0xe9, 0x4e, 0x41, 0xaa, 0x20, 0xe9, 0xd7, 0x70, 0x0f,
+ 0x9d, 0xe8, 0x7e, 0x35, 0xff, 0x30, 0x44,
+ ],
+ [
+ 0xb6, 0xc1, 0xea, 0x92, 0x66, 0x58, 0x97, 0xe0, 0x05, 0x08, 0x46, 0x3d, 0xcc,
+ 0xf6, 0xd8, 0x63, 0x69, 0x63, 0x09, 0xf1, 0x0a, 0x13, 0xdc, 0x53, 0x79, 0xdf,
+ 0xa4, 0x72, 0x3e, 0xc3, 0x69, 0xb0,
+ ],
+ [
+ 0x6e, 0x93, 0xe2, 0xd7, 0x75, 0x83, 0xdc, 0x1d, 0xe9, 0x77, 0x44, 0xd4, 0xa1,
+ 0x89, 0x83, 0x00, 0xe8, 0xee, 0xca, 0x9f, 0x96, 0x97, 0x9f, 0x2f, 0x9e, 0x9c,
+ 0xc3, 0x4f, 0x42, 0x6f, 0x3e, 0x24, 0xc4, 0x13, 0x91, 0x6a, 0x47, 0xb2, 0x76,
+ 0x09, 0x57, 0xf3, 0x49, 0x5a, 0xdc, 0xd0, 0x4d, 0x32,
+ ],
+ [
+ 0xb8, 0xa8, 0x36, 0xac, 0xa9, 0xda, 0xd7, 0x9c, 0x51, 0x73, 0x5d, 0x68, 0xf0,
+ 0x35, 0xb1, 0x56, 0xe2, 0x39, 0xab, 0xa5, 0x34, 0x25, 0x58, 0xff, 0x6b, 0x15,
+ 0x54, 0x19, 0x9d, 0xf8, 0x2d, 0xbe, 0x19, 0x0a, 0x20, 0x65, 0xc0, 0x8c, 0x88,
+ 0xa2, 0x0a, 0xd6, 0xa0, 0xe4, 0x68, 0x63, 0x0b, 0xd4, 0x97, 0x52, 0x1a, 0xab,
+ 0x37, 0x53, 0x12, 0xa5, 0xc3, 0xb6, 0x5c, 0xf2, 0x4d, 0x8b, 0x28, 0x81,
+ ]
+ ),
+ test_case!(
+ [
+ 0x6e, 0xfa, 0x7b, 0x4a, 0x1c, 0x28, 0x36, 0x70, 0x73, 0x82, 0x19, 0xb7, 0xca,
+ 0xd0, 0xaf, 0x7a, 0x2b, 0xc1, 0x65, 0x56, 0x07, 0x84, 0xd2, 0x78, 0xa7, 0xc7,
+ 0x19, 0x9d, 0x5d, 0xc2,
+ ],
+ [
+ 0xf7, 0x6d, 0xc0, 0xd0, 0x81, 0xf3, 0xe2, 0x66, 0xda, 0xff, 0xa8, 0x5d, 0xd6,
+ 0x11, 0x50, 0xf1, 0x9e, 0xc4, 0x6f, 0x73,
+ ],
+ [
+ 0xbd, 0x13, 0x3f, 0x21, 0xdc, 0x8f, 0x72, 0x5f, 0xc1, 0x9a, 0x6d, 0x49, 0x68,
+ 0xd5, 0x86, 0x63, 0xce, 0xf6, 0xad, 0x1d, 0xca, 0x92, 0x67, 0xf2, 0xb2, 0xad,
+ 0x48, 0x85, 0x92, 0x71, 0x0e, 0xa9,
+ ],
+ [
+ 0xdd, 0x77, 0xdf, 0xdc, 0x09, 0xca, 0x11, 0x9a, 0x71, 0x9b, 0x1a, 0xf0, 0xa6,
+ 0x0d, 0x12, 0xd5, 0x0d, 0x30, 0xd5, 0x97, 0x4e, 0xe4, 0xf2, 0x47, 0xad, 0xe1,
+ 0xa2, 0x3e, 0x3b, 0x87, 0x0a, 0xb5, 0xcb, 0x77, 0x5d, 0xea, 0xc4, 0x24, 0xbe,
+ 0xdb, 0xe5, 0x61, 0x5d, 0xad, 0x5d, 0xe7, 0x2a, 0x7e,
+ ],
+ [
+ 0x33, 0x40, 0xab, 0xc2, 0x47, 0xe2, 0xf1, 0xb1, 0x72, 0xfc, 0x8f, 0x21, 0xe7,
+ 0x9c, 0x38, 0x47, 0xa6, 0xd8, 0xc9, 0x63, 0x68, 0xe7, 0x82, 0x42, 0xeb, 0xfa,
+ 0xdb, 0x11, 0x40, 0x30, 0x94, 0xd9, 0x80, 0xe0, 0x8a, 0x6f, 0x2a, 0xe2, 0xdb,
+ 0x9c, 0x6f, 0xc2, 0xe5, 0x5f, 0x9f, 0x65, 0x39, 0x84, 0xe5, 0xd2, 0x9b, 0x9b,
+ 0x55, 0xa7, 0x1f, 0xca, 0xb4, 0x07, 0xc3, 0xe3, 0x6c, 0x33, 0xfb, 0xe7,
+ ]
+ ),
+ test_case!(
+ [
+ 0xb1, 0x17, 0x7b, 0x96, 0x47, 0x7a, 0xf0, 0x55, 0x34, 0x29, 0x6c, 0x56, 0x85,
+ 0xea, 0xf6, 0x6a, 0x88, 0x25, 0x3a, 0xdb, 0x89, 0x15, 0x5b, 0x52, 0x4a, 0x82,
+ 0x2c, 0x0a, 0xc6, 0x7b, 0xb6,
+ ],
+ [
+ 0x92, 0x25, 0xcb, 0x49, 0x05, 0xef, 0x9d, 0x4e, 0x69, 0xa5, 0xd0, 0x10, 0x4e,
+ 0x14, 0x2a, 0x2d, 0x94, 0x8e, 0x45, 0xb9,
+ ],
+ [
+ 0xe4, 0xf1, 0x9f, 0xc0, 0x5e, 0x0d, 0xb2, 0x3e, 0x43, 0xc5, 0xbb, 0xfb, 0x83,
+ 0xf5, 0xa0, 0x92, 0xdc, 0xee, 0x23, 0xde, 0x5e, 0xe5, 0xd0, 0x42, 0x21, 0xc4,
+ 0x76, 0x59, 0x97, 0x4d, 0x9d, 0xcd,
+ ],
+ [
+ 0xb3, 0x8f, 0xc1, 0x95, 0xed, 0x3a, 0x19, 0xf1, 0x77, 0xbe, 0x5c, 0x97, 0xc4,
+ 0x23, 0x88, 0xef, 0x6c, 0x66, 0xdb, 0xa0, 0xb2, 0x46, 0x72, 0x48, 0x33, 0x01,
+ 0x15, 0x44, 0x4c, 0x74, 0x7c, 0x39, 0x37, 0x73, 0xdc, 0x27, 0xf2, 0x2d, 0xda,
+ 0x32, 0x8d, 0x81, 0x86, 0x22, 0xa5, 0xda, 0xab, 0x75,
+ ],
+ [
+ 0xe5, 0x89, 0x07, 0x2a, 0x25, 0xcb, 0xab, 0x14, 0xfe, 0xba, 0xed, 0x44, 0x28,
+ 0xd9, 0x59, 0x3a, 0xac, 0x07, 0xf9, 0x7d, 0x51, 0x34, 0xdf, 0xe5, 0x30, 0x1e,
+ 0xeb, 0x77, 0xee, 0xb0, 0xe4, 0xca, 0x72, 0xb6, 0xd9, 0x1e, 0x43, 0x6f, 0x27,
+ 0x5b, 0xb8, 0x39, 0x18, 0x17, 0xa1, 0x1e, 0x56, 0x65, 0x59, 0xa7, 0x5e, 0xbc,
+ 0x19, 0xe0, 0x90, 0x51, 0xe5, 0x6f, 0x05, 0xd2, 0xdf, 0x07, 0x4f, 0xf0,
+ ]
+ ),
+ test_case!(
+ [
+ 0x41, 0x9a, 0x9f, 0x71, 0x32, 0x26, 0x56, 0x43, 0x50, 0x5b, 0x95, 0xed, 0xdc,
+ 0x61, 0x3f, 0xfa, 0xd2, 0x63, 0x32, 0x29, 0xf8, 0xad, 0x49, 0xc7, 0x8a, 0x45,
+ 0x3c, 0x35, 0x06, 0xd2, 0x28, 0x7b,
+ ],
+ [
+ 0x33, 0xe5, 0xfe, 0x15, 0x13, 0x0c, 0xa8, 0x67, 0xd6, 0x67, 0x84, 0xa0, 0x43,
+ 0x26, 0x26, 0xae, 0x9d, 0x1e, 0x62, 0xfb,
+ ],
+ [
+ 0xf0, 0xbf, 0xf8, 0xdc, 0x02, 0x0a, 0x3d, 0xa2, 0x2d, 0x67, 0xc6, 0x6a, 0x7c,
+ 0x9c, 0x09, 0x10, 0x47, 0xc7, 0x40, 0x3c, 0xcc, 0x92, 0x23, 0x83, 0xea, 0xaf,
+ 0xf2, 0x19, 0xed, 0x5e, 0x02, 0x00,
+ ],
+ [
+ 0x6a, 0xd7, 0x1a, 0x9f, 0xb6, 0x59, 0xfb, 0x71, 0xc1, 0x4c, 0x56, 0x50, 0x35,
+ 0x3d, 0xe5, 0xbc, 0xdb, 0x64, 0x1b, 0xe9, 0x76, 0x9a, 0xbd, 0x75, 0x5f, 0xdb,
+ 0xcd, 0xa7, 0x45, 0x57, 0x48, 0x02, 0x68, 0x6f, 0x39, 0x82, 0xa4, 0xa5, 0x6d,
+ 0xbf, 0x94, 0x4b, 0x31, 0x5f, 0xa6, 0xf5, 0x2b, 0xe4,
+ ],
+ [
+ 0xdd, 0x67, 0x25, 0xd6, 0x97, 0xa6, 0xf0, 0xfa, 0xb1, 0x0b, 0x61, 0x14, 0x07,
+ 0x73, 0x12, 0x37, 0x74, 0x91, 0x7c, 0x72, 0xe1, 0xdf, 0x4c, 0x05, 0x9a, 0xc1,
+ 0x84, 0x66, 0x0c, 0xb6, 0x94, 0x21, 0x2b, 0x22, 0x1c, 0x2b, 0x0e, 0xd4, 0x1b,
+ 0xcf, 0xfb, 0xbc, 0xbb, 0x46, 0x03, 0x0b, 0xde, 0x77, 0x67, 0xf8, 0xa6, 0x06,
+ 0xa2, 0x6c, 0x7a, 0x92, 0x6e, 0x9f, 0xa9, 0x83, 0x14, 0xd3, 0x4b, 0x9b,
+ ]
+ ),
+ test_case!(
+ [
+ 0xdc, 0x62, 0x11, 0x60, 0x97, 0xf2, 0x10, 0x7d, 0xe9, 0xa2, 0xd5, 0xc7, 0xd4,
+ 0x21, 0x0f, 0x82, 0x31, 0x0f, 0xbd, 0x2f, 0x3d, 0x0c, 0xaf, 0x16, 0x70, 0x5f,
+ 0xe3, 0x93, 0xac, 0x48, 0x08, 0x4c, 0x6c,
+ ],
+ [
+ 0x27, 0x34, 0x2f, 0x59, 0x11, 0x5f, 0x41, 0xc1, 0x4d, 0xa1, 0x12, 0x59, 0x8e,
+ 0x0f, 0x85, 0x74, 0x85, 0x73, 0xe1, 0x1b,
+ ],
+ [
+ 0x12, 0xe1, 0x41, 0xca, 0x13, 0x3b, 0xee, 0xdb, 0x18, 0xbe, 0xf2, 0xfd, 0x8e,
+ 0x2a, 0xff, 0xb2, 0x9f, 0x40, 0xd3, 0x16, 0x01, 0xfc, 0x2d, 0x76, 0x9f, 0x7a,
+ 0xf0, 0x39, 0xb3, 0x97, 0x4a, 0x7d,
+ ],
+ [
+ 0x3b, 0x6e, 0x51, 0x91, 0x8b, 0x7d, 0x02, 0x3d, 0x1c, 0x4b, 0xba, 0xe3, 0xba,
+ 0x39, 0x70, 0x10, 0x0e, 0xd3, 0x05, 0x83, 0xd8, 0x42, 0x49, 0x27, 0xde, 0x61,
+ 0x81, 0x29, 0xfe, 0xc4, 0x42, 0x3d, 0x18, 0xc3, 0x9c, 0x9a, 0x26, 0x71, 0x11,
+ 0x7e, 0xb1, 0xd6, 0x74, 0x4f, 0xd2, 0xaa, 0x60, 0x9f,
+ ],
+ [
+ 0xc2, 0x72, 0xff, 0xe7, 0x5f, 0x13, 0xcf, 0xb3, 0xf7, 0x3d, 0x76, 0x5c, 0x45,
+ 0xe8, 0x95, 0x43, 0x22, 0x0f, 0x42, 0xd2, 0xfe, 0x6b, 0x9c, 0x88, 0xf9, 0x43,
+ 0x8f, 0x3e, 0x8d, 0x54, 0x0d, 0xe9, 0xde, 0xe0, 0xcd, 0x84, 0x8b, 0xca, 0xbd,
+ 0x67, 0x07, 0x11, 0x0d, 0x1d, 0x99, 0xe8, 0xb2, 0x7f, 0xff, 0x97, 0x1f, 0x16,
+ 0xd7, 0xf4, 0x5f, 0x04, 0x8e, 0x89, 0x97, 0xcd, 0xff, 0x56, 0x58, 0xcc,
+ ]
+ ),
+ test_case!(
+ [
+ 0x6f, 0x56, 0xad, 0xd8, 0x88, 0xaa, 0xe5, 0x66, 0xc6, 0xee, 0x07, 0xf5, 0x26,
+ 0x3e, 0xc7, 0xd7, 0x29, 0xf3, 0xc3, 0x0c, 0xe6, 0x0f, 0x7e, 0x12, 0x8a, 0x9a,
+ 0xa1, 0x61, 0x90, 0xe1, 0x65, 0x53, 0x51, 0x79,
+ ],
+ [
+ 0x30, 0xac, 0x24, 0xff, 0x40, 0x9b, 0x5b, 0x10, 0x49, 0x9c, 0x18, 0xfb, 0xf8,
+ 0xba, 0x32, 0xf0, 0x45, 0x28, 0x1a, 0xc2,
+ ],
+ [
+ 0x5c, 0x18, 0x9a, 0x98, 0x5a, 0xcc, 0x69, 0xe2, 0x9d, 0xe6, 0xd7, 0xd2, 0xb2,
+ 0x53, 0x07, 0x4a, 0xcd, 0x39, 0xc5, 0x92, 0x14, 0x1f, 0xbf, 0x67, 0x1b, 0x5a,
+ 0x29, 0x47, 0xcd, 0xc2, 0x38, 0x6f,
+ ],
+ [
+ 0x00, 0x20, 0x20, 0x82, 0x9f, 0x45, 0xd8, 0x34, 0xae, 0x4a, 0xd6, 0xcd, 0x37,
+ 0xe4, 0x9c, 0x91, 0x39, 0xad, 0xf9, 0xaf, 0xae, 0x1c, 0x09, 0x6f, 0x32, 0x95,
+ 0xc9, 0xe2, 0xcf, 0x59, 0x04, 0xec, 0x27, 0xd8, 0x94, 0x2a, 0xce, 0xd8, 0xd1,
+ 0xff, 0xd9, 0x9f, 0x2d, 0x0e, 0x32, 0x45, 0x2c, 0xce,
+ ],
+ [
+ 0x7a, 0x4d, 0x9a, 0x8e, 0x1a, 0x7a, 0x7a, 0x18, 0x44, 0xfb, 0x50, 0xce, 0xbc,
+ 0x71, 0x8b, 0xe6, 0x06, 0x8e, 0x2b, 0xd1, 0x3e, 0x82, 0xee, 0xdb, 0xd0, 0x55,
+ 0xa9, 0xb8, 0xb6, 0x79, 0xc9, 0x61, 0xcb, 0x06, 0xbe, 0xaf, 0x89, 0x2d, 0xde,
+ 0x7b, 0x06, 0x44, 0xba, 0xdb, 0xe3, 0xf5, 0xda, 0x6b, 0x61, 0x63, 0x19, 0x2e,
+ 0xf0, 0xd9, 0xe1, 0xb3, 0xce, 0x5e, 0xf5, 0x3b, 0x6a, 0x82, 0x2e, 0x62,
+ ]
+ ),
+ test_case!(
+ [
+ 0x51, 0xf3, 0x34, 0xe7, 0x7e, 0xcc, 0x29, 0x8c, 0x68, 0x57, 0xec, 0xe7, 0x86,
+ 0x8b, 0xde, 0xd4, 0x64, 0xa3, 0x30, 0xe3, 0x2d, 0xd1, 0x39, 0xb1, 0x06, 0xe0,
+ 0x66, 0xb7, 0x99, 0x34, 0xa9, 0x70, 0x1b, 0x18, 0xa6,
+ ],
+ [
+ 0xd0, 0x87, 0xbc, 0xb9, 0xac, 0x61, 0xd6, 0xd9, 0x5e, 0xc1, 0x44, 0x6e, 0x97,
+ 0x01, 0xe9, 0xc3, 0x2c, 0x34, 0x7e, 0x94,
+ ],
+ [
+ 0xdf, 0x9b, 0x7b, 0x38, 0x62, 0x03, 0x07, 0x80, 0x9e, 0x4f, 0x99, 0xa3, 0x34,
+ 0x37, 0x2d, 0xb1, 0xbb, 0x6b, 0x81, 0x89, 0xa1, 0x25, 0x79, 0x8e, 0x90, 0xb9,
+ 0xa5, 0x2b, 0x67, 0x43, 0x61, 0xeb,
+ ],
+ [
+ 0x1f, 0x29, 0x36, 0xe6, 0x63, 0x36, 0x87, 0xb2, 0x35, 0xe0, 0xba, 0x66, 0x3a,
+ 0x91, 0xdc, 0x97, 0x71, 0xd3, 0x39, 0x60, 0x7c, 0x85, 0x2f, 0x6a, 0x4a, 0x60,
+ 0xf8, 0x43, 0x4a, 0x94, 0x85, 0xe3, 0x4d, 0xee, 0xfb, 0x18, 0x5c, 0x77, 0xad,
+ 0xdb, 0xd7, 0xb1, 0x70, 0xd9, 0x95, 0x17, 0xa8, 0x1c,
+ ],
+ [
+ 0x84, 0xc2, 0x32, 0xd8, 0x6d, 0xb9, 0x62, 0x96, 0x94, 0x7c, 0xbf, 0x6b, 0xd1,
+ 0x05, 0xf5, 0xe4, 0xfe, 0x6b, 0x66, 0x69, 0x3b, 0x6c, 0x35, 0xb3, 0x11, 0x28,
+ 0xd9, 0x67, 0x7a, 0xb7, 0xa6, 0x37, 0x1f, 0x75, 0x2a, 0xf9, 0x31, 0x3c, 0xcb,
+ 0xf7, 0xb4, 0xd6, 0xfb, 0x39, 0xbb, 0x98, 0xe4, 0x32, 0x90, 0xf6, 0x01, 0x8d,
+ 0x20, 0x27, 0x7e, 0xad, 0x9e, 0x04, 0x30, 0x32, 0x12, 0x83, 0x5e, 0x09,
+ ]
+ ),
+ test_case!(
+ [
+ 0x74, 0x3a, 0x02, 0xd0, 0x15, 0xee, 0xdd, 0x7a, 0x0b, 0xbd, 0x52, 0x00, 0x99,
+ 0xce, 0x2c, 0xc5, 0xbd, 0x5e, 0x56, 0xba, 0x28, 0x48, 0xf3, 0xa7, 0x3c, 0xaf,
+ 0x62, 0x6e, 0xf1, 0x9d, 0x78, 0x01, 0xfb, 0xf1, 0x56, 0xf6,
+ ],
+ [
+ 0xeb, 0x3c, 0x1d, 0xaf, 0x0d, 0x1c, 0x66, 0x57, 0x99, 0xf1, 0xaf, 0xbe, 0xb1,
+ 0xff, 0xbf, 0xf4, 0x8c, 0x11, 0x16, 0x8f,
+ ],
+ [
+ 0x5b, 0x67, 0x80, 0xf1, 0x41, 0x6b, 0x0b, 0xf5, 0x0d, 0xc7, 0x92, 0xf7, 0x96,
+ 0x1e, 0xca, 0xaf, 0x91, 0x8d, 0xba, 0xfb, 0x8f, 0xea, 0x75, 0xcf, 0xf9, 0xd8,
+ 0xc5, 0x88, 0xa2, 0x96, 0x72, 0x15,
+ ],
+ [
+ 0xa3, 0xa6, 0xfc, 0xfa, 0x55, 0x1c, 0xbc, 0xf3, 0x25, 0x1b, 0x80, 0xb8, 0xd4,
+ 0xe1, 0x95, 0x3a, 0xaf, 0xb7, 0x13, 0x7e, 0xa0, 0x88, 0x9e, 0xc8, 0xa9, 0x33,
+ 0xca, 0xda, 0x93, 0x4b, 0x12, 0x4f, 0xd2, 0x85, 0xbb, 0x49, 0x01, 0xc8, 0x26,
+ 0x01, 0x3f, 0x0e, 0xfa, 0x12, 0x5e, 0x44, 0x14, 0xb4,
+ ],
+ [
+ 0x19, 0xa5, 0x0c, 0xae, 0x5f, 0x4d, 0x6a, 0xdb, 0x19, 0x03, 0x58, 0x88, 0xf3,
+ 0x44, 0xed, 0x4e, 0xdf, 0xc2, 0x2d, 0xe3, 0xd7, 0x2d, 0xba, 0x63, 0xa6, 0x2a,
+ 0x0b, 0x12, 0x40, 0x78, 0x5a, 0x06, 0xd7, 0xe8, 0x16, 0x38, 0x87, 0x75, 0x15,
+ 0x24, 0xe1, 0xa0, 0xde, 0x44, 0x5c, 0x47, 0x84, 0x38, 0x3d, 0xc6, 0x06, 0xff,
+ 0xad, 0x6e, 0x2d, 0xbe, 0x3c, 0xb1, 0x4a, 0x67, 0xc7, 0x82, 0x91, 0x8e,
+ ]
+ ),
+ test_case!(
+ [
+ 0xee, 0x55, 0x5c, 0x2e, 0x82, 0x69, 0x79, 0x10, 0xa0, 0x46, 0x7b, 0x3a, 0x9a,
+ 0xd4, 0xbe, 0x62, 0xc3, 0x57, 0xc9, 0x57, 0x6b, 0xfe, 0x0f, 0x75, 0x2e, 0xb9,
+ 0x3a, 0x21, 0x5e, 0xb4, 0x65, 0x56, 0x20, 0xf2, 0xa3, 0x33, 0x7c,
+ ],
+ [
+ 0x5c, 0xc1, 0x0f, 0x43, 0x53, 0x49, 0xd7, 0x56, 0x56, 0x05, 0x4d, 0x16, 0xaf,
+ 0xbc, 0x1b, 0xc5, 0xd7, 0x67, 0xbf, 0xf6,
+ ],
+ [
+ 0x92, 0xd9, 0x3f, 0xf3, 0x71, 0x99, 0x45, 0x7f, 0x40, 0x38, 0x0f, 0x1a, 0x1c,
+ 0x34, 0xf8, 0x09, 0xa1, 0x20, 0x41, 0xb0, 0xa1, 0x19, 0x2f, 0xcc, 0x5a, 0xab,
+ 0xe3, 0xcc, 0xcf, 0x50, 0xb0, 0xb2,
+ ],
+ [
+ 0x0e, 0xc7, 0x58, 0x8b, 0x1f, 0x59, 0x71, 0x4b, 0x06, 0x5e, 0x75, 0x67, 0x52,
+ 0xbe, 0x56, 0xec, 0xdd, 0x83, 0x49, 0x0c, 0x7f, 0x1b, 0xa1, 0x05, 0x68, 0xaf,
+ 0xf9, 0x1e, 0x48, 0x7b, 0x9c, 0xcf, 0x03, 0xea, 0xbf, 0xff, 0x0a, 0x88, 0x61,
+ 0xfd, 0xf0, 0x02, 0xb8, 0x6a, 0x2e, 0xc5, 0xb3, 0x3a,
+ ],
+ [
+ 0x13, 0x16, 0x50, 0xf5, 0x2a, 0x49, 0x75, 0x05, 0xb8, 0x03, 0x78, 0x00, 0xed,
+ 0x7e, 0x5e, 0x3a, 0x69, 0xf7, 0x3b, 0x9a, 0x46, 0xef, 0xf0, 0xc9, 0x96, 0xa1,
+ 0xdb, 0x08, 0x0f, 0x13, 0x58, 0xa3, 0x18, 0xca, 0x09, 0x1e, 0xe6, 0xfc, 0x18,
+ 0x0c, 0xd0, 0xad, 0x90, 0x56, 0xef, 0xc3, 0x19, 0xeb, 0x46, 0x37, 0x45, 0x64,
+ 0x1c, 0x81, 0x42, 0x39, 0x4d, 0x46, 0x10, 0x04, 0xe9, 0x4d, 0x8a, 0xa6,
+ ]
+ ),
+ test_case!(
+ [
+ 0xd7, 0x88, 0x2d, 0x5a, 0xee, 0x5a, 0xbb, 0x51, 0xe0, 0x48, 0xfd, 0xed, 0xfa,
+ 0x23, 0xa6, 0xde, 0x55, 0x68, 0x3e, 0x58, 0x56, 0x45, 0x0f, 0x12, 0x73, 0x7b,
+ 0xd7, 0xc7, 0xeb, 0x88, 0xf6, 0x57, 0xad, 0x64, 0x77, 0x09, 0x46, 0x55,
+ ],
+ [
+ 0x16, 0x09, 0x24, 0xdb, 0x8f, 0x81, 0xc5, 0x6d, 0x84, 0xc8, 0x52, 0x2e, 0x1b,
+ 0x20, 0xb4, 0x09, 0x29, 0x0a, 0x48, 0xed,
+ ],
+ [
+ 0x37, 0xe0, 0xf2, 0xa5, 0x5f, 0xf6, 0xcb, 0x9c, 0x1c, 0xbd, 0x96, 0x6f, 0xf1,
+ 0x0f, 0x80, 0xd5, 0xcb, 0xe9, 0xf4, 0xfa, 0x40, 0x4f, 0x0d, 0x36, 0xa4, 0xb7,
+ 0x5b, 0x4a, 0x3a, 0xe3, 0xb1, 0xb8,
+ ],
+ [
+ 0x9f, 0xce, 0x73, 0xb7, 0x50, 0xa7, 0x7d, 0x5f, 0xd9, 0x76, 0x49, 0xf9, 0x9e,
+ 0xc5, 0xb9, 0x4a, 0x9b, 0x25, 0xcf, 0x0b, 0x14, 0x49, 0xfc, 0xd6, 0x9f, 0x3d,
+ 0xcf, 0x1d, 0xb8, 0xbc, 0x45, 0xda, 0x11, 0x02, 0xb3, 0x0a, 0x43, 0x65, 0x33,
+ 0xb6, 0xf5, 0xe8, 0x9c, 0x60, 0x8b, 0x7b, 0x38, 0x79,
+ ],
+ [
+ 0x34, 0xff, 0x6e, 0x2b, 0xa9, 0x2a, 0x37, 0x3a, 0x21, 0x4f, 0xbd, 0x6c, 0x4c,
+ 0x81, 0xea, 0xfc, 0xa6, 0xc4, 0xc6, 0xb1, 0x73, 0x51, 0x32, 0x10, 0x7a, 0x02,
+ 0x87, 0x80, 0x81, 0x7e, 0xfd, 0x20, 0x97, 0x63, 0xa7, 0x96, 0xba, 0xa4, 0x29,
+ 0x49, 0xad, 0x78, 0x24, 0xe7, 0x72, 0xac, 0x37, 0x86, 0x86, 0xd5, 0x42, 0x25,
+ 0x94, 0x59, 0xec, 0x97, 0x74, 0x70, 0x7f, 0x2c, 0x2c, 0x95, 0x9b, 0x18,
+ ]
+ ),
+ test_case!(
+ [
+ 0xfd, 0xec, 0xa1, 0xea, 0xd1, 0x0f, 0x2d, 0xb9, 0x2e, 0xce, 0x0f, 0x10, 0x28,
+ 0xb5, 0x8a, 0x23, 0xfd, 0xed, 0xc1, 0x64, 0xab, 0xfc, 0x52, 0x9d, 0x17, 0xe5,
+ 0x44, 0x29, 0xd3, 0x76, 0x1b, 0xe7, 0x99, 0xf5, 0x47, 0xa9, 0xc4, 0xb6, 0x55,
+ ],
+ [
+ 0x70, 0x84, 0x56, 0xb0, 0xb7, 0xa0, 0x97, 0x3d, 0x11, 0x27, 0x60, 0xd2, 0x88,
+ 0x67, 0x5c, 0xca, 0x8e, 0x44, 0xfc, 0x93,
+ ],
+ [
+ 0x9f, 0xb9, 0x5b, 0x27, 0x10, 0xe7, 0x13, 0xb0, 0x9d, 0x35, 0xe2, 0x68, 0x4c,
+ 0x8c, 0x01, 0x63, 0xcd, 0xc1, 0xf2, 0x01, 0x30, 0x10, 0x42, 0x87, 0xe4, 0xa3,
+ 0x22, 0x35, 0x55, 0xbc, 0xfb, 0x96,
+ ],
+ [
+ 0x5e, 0x04, 0xa0, 0x59, 0x2e, 0xf1, 0xe6, 0xf2, 0x18, 0xd8, 0xdc, 0xa6, 0xf8,
+ 0xf7, 0x88, 0x32, 0xa1, 0xec, 0x48, 0x04, 0xfc, 0xa7, 0xf6, 0xa2, 0x8b, 0x3e,
+ 0x8f, 0x7e, 0xa8, 0x64, 0x87, 0x25, 0x4b, 0xba, 0xc7, 0x27, 0x4c, 0xee, 0xe4,
+ 0x93, 0xbb, 0x1d, 0x62, 0x71, 0xfc, 0xe1, 0x22, 0x54,
+ ],
+ [
+ 0x03, 0x7c, 0x2c, 0x76, 0x85, 0xd0, 0xca, 0x2d, 0x9c, 0xbd, 0xe6, 0xe8, 0x42,
+ 0xd6, 0xcd, 0x65, 0x74, 0xaf, 0xd2, 0x95, 0xfb, 0x8c, 0xc6, 0x25, 0x14, 0x13,
+ 0x8d, 0x9f, 0x50, 0x59, 0x63, 0x03, 0xc2, 0x29, 0x92, 0x06, 0x22, 0xc8, 0x85,
+ 0x03, 0x6a, 0x29, 0x84, 0x71, 0xc3, 0xd1, 0x47, 0x49, 0x66, 0x8f, 0xa1, 0xa5,
+ 0xb3, 0xa6, 0x78, 0x95, 0x98, 0x7e, 0x23, 0x81, 0xc9, 0xd5, 0x4f, 0xd1,
+ ]
+ ),
+ test_case!(
+ [
+ 0x26, 0x66, 0x74, 0xa4, 0x1d, 0x40, 0x05, 0x26, 0x6d, 0xa3, 0x5b, 0xd1, 0xb9,
+ 0x71, 0xd0, 0xb2, 0xa2, 0xad, 0xd6, 0xa8, 0x77, 0x9d, 0x32, 0xd7, 0x5b, 0x48,
+ 0xa9, 0x45, 0x52, 0x63, 0x65, 0xe1, 0x49, 0xce, 0x04, 0x25, 0xcf, 0x93, 0x28,
+ 0x08,
+ ],
+ [
+ 0x43, 0xe8, 0x6b, 0x9c, 0x6b, 0xcb, 0x9f, 0x02, 0x8a, 0xa3, 0x6a, 0xc8, 0x65,
+ 0xaa, 0x5d, 0xea, 0xcc, 0x0b, 0xda, 0xc1,
+ ],
+ [
+ 0xa3, 0x7f, 0xd5, 0x05, 0xc4, 0x36, 0xba, 0xa1, 0xe5, 0x41, 0x73, 0xf2, 0x34,
+ 0xb3, 0x50, 0xd3, 0x09, 0xd6, 0xbf, 0xeb, 0x5c, 0x43, 0x42, 0xbe, 0x1e, 0xfd,
+ 0x80, 0x46, 0xc0, 0x26, 0x2a, 0x02,
+ ],
+ [
+ 0xee, 0x78, 0x5e, 0x97, 0x0d, 0x5e, 0x91, 0x76, 0x2a, 0x52, 0x5f, 0x2e, 0x99,
+ 0xb6, 0xd0, 0x53, 0x70, 0x8a, 0x34, 0x92, 0x31, 0xa1, 0xaf, 0x1c, 0x7f, 0x5d,
+ 0xbf, 0x36, 0x6f, 0x32, 0x3c, 0xe7, 0x80, 0xb3, 0x7c, 0x97, 0x7c, 0x09, 0x86,
+ 0xba, 0x25, 0xea, 0x94, 0x2d, 0xd8, 0x5d, 0xe4, 0x72,
+ ],
+ [
+ 0xde, 0xd0, 0x30, 0x07, 0xb0, 0x8c, 0x5b, 0x6a, 0xcf, 0xe7, 0xd6, 0x44, 0xdb,
+ 0x13, 0x7c, 0xcd, 0x46, 0x7b, 0xd3, 0xd7, 0x32, 0x92, 0xb4, 0xde, 0xc0, 0x59,
+ 0x66, 0x43, 0x03, 0x25, 0x87, 0xb9, 0x60, 0xa8, 0x07, 0xec, 0x3e, 0x5a, 0xe8,
+ 0x82, 0x99, 0x00, 0x9f, 0x8c, 0xba, 0x60, 0xca, 0x27, 0x08, 0xf1, 0x32, 0xe4,
+ 0x40, 0xd5, 0x65, 0x62, 0xd1, 0x40, 0x89, 0xc6, 0x01, 0xfb, 0xc6, 0xc6,
+ ]
+ ),
+ test_case!(
+ [
+ 0x20, 0x12, 0x93, 0xbe, 0xea, 0xc8, 0xde, 0x2d, 0xc6, 0x86, 0xe6, 0x33, 0xa5,
+ 0x00, 0xb6, 0xfb, 0x66, 0x05, 0xd6, 0xbf, 0x03, 0xc5, 0xea, 0x44, 0x15, 0x62,
+ 0x25, 0x34, 0x58, 0x5d, 0x3b, 0x13, 0x59, 0x20, 0x21, 0x42, 0xfa, 0xb4, 0xbe,
+ 0x2a, 0xb1,
+ ],
+ [
+ 0x8c, 0x93, 0xf9, 0x39, 0xd5, 0xe8, 0xe1, 0x89, 0xd1, 0x51, 0x09, 0xe1, 0xe8,
+ 0x85, 0x36, 0xdf, 0xf0, 0x03, 0xc3, 0x21,
+ ],
+ [
+ 0x33, 0x5e, 0xfd, 0x1e, 0xf1, 0x3f, 0x9a, 0x36, 0x70, 0xa3, 0x42, 0x75, 0x37,
+ 0x34, 0x20, 0xbe, 0xb6, 0x09, 0x50, 0x48, 0xd0, 0x6c, 0x63, 0xac, 0xb6, 0x2e,
+ 0x12, 0xaa, 0xe0, 0xd9, 0xbd, 0xf6,
+ ],
+ [
+ 0xe9, 0x9d, 0xf0, 0x00, 0xe8, 0x03, 0x98, 0x7a, 0x47, 0x6b, 0x48, 0xd4, 0xc8,
+ 0xdd, 0x6c, 0xf3, 0xdf, 0x20, 0x69, 0xa0, 0x82, 0xca, 0xe4, 0x32, 0xcc, 0x90,
+ 0x81, 0x3a, 0x19, 0xea, 0xf6, 0xe7, 0x22, 0x7d, 0x55, 0xd1, 0xee, 0x6e, 0x7d,
+ 0xe3, 0xa8, 0xdb, 0x9c, 0x73, 0x29, 0xd4, 0xdd, 0xd8,
+ ],
+ [
+ 0x7a, 0xb9, 0x04, 0x46, 0x5f, 0xc0, 0xdf, 0x7f, 0x3b, 0xb3, 0x92, 0xdc, 0xe8,
+ 0x58, 0x12, 0xd2, 0xf0, 0x61, 0x82, 0x6e, 0xeb, 0x64, 0x57, 0x14, 0x46, 0xb1,
+ 0xa6, 0x6a, 0x41, 0x45, 0x2c, 0x44, 0xa8, 0xf9, 0x2c, 0xe5, 0x91, 0xa0, 0x06,
+ 0x8c, 0xbe, 0xe9, 0xc2, 0x0e, 0x0b, 0x54, 0xad, 0x60, 0x94, 0x24, 0x71, 0x67,
+ 0xa5, 0xfd, 0x0c, 0x47, 0x0d, 0xb7, 0xe7, 0x0a, 0x52, 0x28, 0x76, 0xfa,
+ ]
+ ),
+ test_case!(
+ [
+ 0x25, 0x24, 0x4e, 0x7d, 0xd3, 0x5c, 0x19, 0x6c, 0x65, 0x4f, 0x27, 0x11, 0xd5,
+ 0xa9, 0xc6, 0xbe, 0x54, 0xb6, 0xa5, 0xb5, 0x58, 0x52, 0xcc, 0x84, 0x66, 0x23,
+ 0x15, 0x07, 0x50, 0xc2, 0x3e, 0xf8, 0xe2, 0x8d, 0x36, 0x94, 0x41, 0x65, 0x1a,
+ 0x65, 0xe3, 0x34,
+ ],
+ [
+ 0x27, 0x1b, 0x02, 0xa7, 0xaa, 0x9d, 0x9e, 0x4b, 0xbc, 0x8d, 0x61, 0x86, 0x60,
+ 0x13, 0x02, 0xfa, 0x67, 0x39, 0x55, 0xdf,
+ ],
+ [
+ 0x6e, 0x61, 0x59, 0xc6, 0x7c, 0x2f, 0x05, 0x87, 0xcf, 0xeb, 0x71, 0x36, 0x85,
+ 0xf0, 0x89, 0xc1, 0xf7, 0xf4, 0xf9, 0xfb, 0xf8, 0xc2, 0xf9, 0xfd, 0x92, 0xbe,
+ 0xaa, 0x1d, 0x92, 0xc5, 0x2b, 0x9f,
+ ],
+ [
+ 0xbc, 0x62, 0x9f, 0x44, 0x9f, 0x8c, 0x83, 0x39, 0x93, 0xda, 0xbe, 0xa0, 0xf8,
+ 0x91, 0xa9, 0xf9, 0xb5, 0x7c, 0x03, 0x8d, 0x35, 0x56, 0x02, 0xf2, 0xee, 0xff,
+ 0x4c, 0x32, 0xb3, 0x83, 0xd3, 0x22, 0x46, 0x87, 0x17, 0xf9, 0x77, 0x3e, 0x19,
+ 0xc6, 0x91, 0x6f, 0xb4, 0x68, 0x7c, 0xd3, 0x0a, 0x6e,
+ ],
+ [
+ 0x97, 0xa2, 0xce, 0x76, 0xb8, 0x38, 0x72, 0xbe, 0x8b, 0x06, 0x13, 0xf1, 0x94,
+ 0xfc, 0xd5, 0x15, 0x8d, 0xb8, 0x56, 0xf9, 0x4f, 0x39, 0x65, 0x92, 0x34, 0x2d,
+ 0x68, 0xcf, 0x26, 0x20, 0x0d, 0x8e, 0x15, 0x97, 0x04, 0x71, 0x12, 0x97, 0x12,
+ 0x45, 0xad, 0xe2, 0x67, 0x8d, 0xbe, 0x92, 0x97, 0x7a, 0x52, 0x01, 0x0c, 0x84,
+ 0x40, 0xf2, 0x3d, 0x4b, 0x41, 0x04, 0x34, 0xef, 0x88, 0x59, 0xe1, 0xb7,
+ ]
+ ),
+ test_case!(
+ [
+ 0x35, 0xe2, 0xf7, 0x9c, 0x2a, 0x74, 0x75, 0xfa, 0x8d, 0x56, 0x0f, 0x66, 0xc7,
+ 0xae, 0xe7, 0x96, 0x64, 0x0d, 0xf8, 0x8b, 0x66, 0x8a, 0xf4, 0x5d, 0x76, 0xd2,
+ 0x08, 0xc2, 0xf4, 0x46, 0x0e, 0x9d, 0x55, 0x27, 0x1f, 0x12, 0x95, 0x0b, 0xbf,
+ 0x5f, 0xfc, 0xa8, 0xd2,
+ ],
+ [
+ 0xda, 0x0a, 0x69, 0x3e, 0x9d, 0xca, 0x7f, 0x85, 0x5c, 0xd5, 0x28, 0x07, 0xeb,
+ 0x1f, 0xde, 0xc6, 0x17, 0xa8, 0xab, 0xd3,
+ ],
+ [
+ 0x71, 0x36, 0xfe, 0x0b, 0xf1, 0x1a, 0xf8, 0x79, 0x52, 0x97, 0xb1, 0x33, 0x4d,
+ 0x2d, 0x29, 0x4b, 0xe4, 0x8d, 0x47, 0x02, 0x36, 0xe6, 0x66, 0x45, 0xb9, 0x67,
+ 0xb8, 0xe9, 0xe6, 0xbe, 0xd7, 0xc0,
+ ],
+ [
+ 0x59, 0x74, 0x0e, 0x65, 0xca, 0x44, 0xa5, 0x2e, 0x39, 0x55, 0x85, 0x56, 0x17,
+ 0xc0, 0x50, 0x8e, 0x60, 0x90, 0xc8, 0x0d, 0xbe, 0x1b, 0x8d, 0x0e, 0x7c, 0xba,
+ 0xa6, 0xa2, 0xe6, 0x24, 0xf6, 0x7e, 0xc8, 0x9e, 0x6b, 0x66, 0xce, 0x35, 0x50,
+ 0x44, 0x37, 0x62, 0xb7, 0x90, 0x2f, 0xec, 0x27, 0x6a,
+ ],
+ [
+ 0x00, 0x13, 0x62, 0xed, 0x76, 0x71, 0xaf, 0x24, 0xf5, 0x64, 0x20, 0xd6, 0x23,
+ 0xf2, 0x26, 0xf7, 0xd3, 0x2e, 0xfa, 0xe4, 0xcb, 0x66, 0xd4, 0x5c, 0x2a, 0x9f,
+ 0x84, 0xc3, 0x5c, 0xd8, 0x5f, 0x98, 0x8a, 0x53, 0x1f, 0x29, 0x45, 0xb4, 0x82,
+ 0xf8, 0xea, 0x1a, 0x5d, 0xaa, 0xe0, 0x34, 0xdb, 0xc6, 0x0f, 0xd8, 0x7c, 0x47,
+ 0x9d, 0x50, 0x28, 0x3a, 0xec, 0x7c, 0x25, 0x15, 0xbe, 0xa4, 0xf8, 0x3b,
+ ]
+ ),
+ test_case!(
+ [
+ 0x1a, 0xc5, 0x22, 0x68, 0xc0, 0x9f, 0x87, 0xfc, 0x6a, 0x92, 0x3b, 0xc9, 0x69,
+ 0xfb, 0x43, 0x54, 0xa5, 0x10, 0x9c, 0x46, 0xf6, 0xb4, 0xa2, 0xd3, 0xe4, 0xd9,
+ 0xa6, 0x10, 0x0f, 0x4e, 0x1f, 0x73, 0x82, 0xe6, 0x2e, 0x8b, 0x91, 0xfe, 0x5c,
+ 0x58, 0x32, 0x05, 0x7f, 0x68,
+ ],
+ [
+ 0xbf, 0x02, 0xa6, 0x5f, 0xec, 0x11, 0x24, 0xb7, 0xcd, 0x7c, 0x9d, 0xba, 0x2f,
+ 0xa0, 0xb0, 0x46, 0xff, 0x30, 0xd2, 0x86,
+ ],
+ [
+ 0x67, 0x96, 0xa7, 0xc3, 0x09, 0x09, 0xf3, 0xa3, 0x94, 0x7d, 0x36, 0x9c, 0xb7,
+ 0x4b, 0x9f, 0x72, 0xf2, 0x59, 0x19, 0x5f, 0xb9, 0x08, 0x63, 0xf2, 0x2c, 0xfb,
+ 0x91, 0x2e, 0x2a, 0x77, 0xc9, 0x63,
+ ],
+ [
+ 0x38, 0xef, 0xde, 0xc2, 0xf7, 0xb4, 0xc5, 0x89, 0xe9, 0x06, 0x8a, 0x57, 0xcd,
+ 0x0b, 0x9e, 0x5a, 0x66, 0xe7, 0xe5, 0xd9, 0xef, 0xfa, 0xc6, 0xa8, 0xa6, 0x43,
+ 0xc6, 0xcd, 0x57, 0x93, 0x87, 0x8d, 0x92, 0x7a, 0xdc, 0x50, 0xff, 0x45, 0xad,
+ 0xdc, 0x7c, 0xe3, 0x46, 0xb8, 0x1a, 0x86, 0x3e, 0xd8,
+ ],
+ [
+ 0xd9, 0x2e, 0x8a, 0x61, 0x20, 0x24, 0x4e, 0x1a, 0x56, 0x2b, 0x76, 0xd5, 0xc7,
+ 0xcf, 0x69, 0xc7, 0x3a, 0xbd, 0xbb, 0x88, 0x3d, 0xe9, 0x16, 0x88, 0x7b, 0x32,
+ 0x8c, 0xde, 0x79, 0xa6, 0x03, 0x68, 0x7d, 0xef, 0x83, 0x71, 0xe9, 0xef, 0xdd,
+ 0x13, 0x36, 0x9b, 0xe5, 0x36, 0xa5, 0x60, 0x21, 0x9d, 0xc2, 0x9c, 0xa3, 0xff,
+ 0x3a, 0x54, 0xfa, 0xd7, 0x77, 0xa9, 0x50, 0x12, 0xfc, 0x14, 0xbc, 0x3f,
+ ]
+ ),
+ test_case!(
+ [
+ 0xfb, 0x6b, 0xac, 0xbe, 0x3a, 0x17, 0x39, 0x5a, 0x3c, 0x2b, 0x5c, 0x37, 0x9f,
+ 0xea, 0xf0, 0xf0, 0x64, 0x51, 0x36, 0xce, 0x1a, 0xe5, 0x95, 0x7b, 0x9f, 0x95,
+ 0x0b, 0x56, 0x9b, 0x09, 0x2d, 0xc8, 0x11, 0x36, 0xea, 0x1b, 0x99, 0x93, 0xe0,
+ 0x9a, 0x66, 0xb0, 0xa1, 0x4a, 0x66,
+ ],
+ [
+ 0xab, 0x81, 0x02, 0x81, 0x1a, 0x8c, 0x3b, 0xb3, 0x1d, 0x11, 0x1a, 0xe9, 0x51,
+ 0xa0, 0x0e, 0xd5, 0xa3, 0x9c, 0x5b, 0x96,
+ ],
+ [
+ 0xda, 0xb8, 0x83, 0x7a, 0x4f, 0xb7, 0x69, 0x05, 0x3a, 0xa4, 0x75, 0x01, 0xed,
+ 0xe9, 0x0f, 0xf7, 0xbd, 0x9b, 0xe6, 0x93, 0x9e, 0x44, 0x0f, 0x42, 0x6a, 0x2c,
+ 0x66, 0xa0, 0x23, 0x9d, 0xed, 0xea,
+ ],
+ [
+ 0x12, 0x1f, 0xa1, 0x78, 0x49, 0xd4, 0x36, 0x1c, 0xf4, 0xbc, 0x13, 0x85, 0x13,
+ 0xdf, 0x89, 0x5a, 0x95, 0xc3, 0xa1, 0xd6, 0xf3, 0xd0, 0x2f, 0xad, 0xb1, 0x9d,
+ 0x00, 0x84, 0xe8, 0x13, 0xb1, 0x66, 0xfd, 0x94, 0xd0, 0x02, 0xdc, 0x43, 0x9c,
+ 0xaf, 0x59, 0x11, 0x2b, 0x82, 0x24, 0x08, 0xe5, 0xb4,
+ ],
+ [
+ 0x33, 0x34, 0xcd, 0xbc, 0x7e, 0xcb, 0xea, 0xa8, 0xe4, 0x4a, 0xc5, 0xf9, 0x28,
+ 0xf9, 0x6b, 0x56, 0xc7, 0xb8, 0xb9, 0x90, 0xb2, 0xbd, 0x8a, 0xef, 0x99, 0x89,
+ 0x52, 0x62, 0x02, 0x9e, 0xf5, 0x26, 0x77, 0x5a, 0x4a, 0xa3, 0xc6, 0xa5, 0xf2,
+ 0x58, 0xcb, 0xa8, 0x99, 0xa6, 0x52, 0x85, 0xfe, 0xd7, 0x75, 0xae, 0x13, 0x70,
+ 0x10, 0x85, 0xf9, 0x0a, 0xa0, 0xc6, 0x7d, 0xd3, 0x59, 0xbb, 0x55, 0x01,
+ ]
+ ),
+ test_case!(
+ [
+ 0xaa, 0xdf, 0xb1, 0x66, 0x9c, 0x82, 0x45, 0x46, 0x36, 0x07, 0x8b, 0x78, 0x8b,
+ 0x67, 0xe3, 0x6d, 0xfa, 0x2a, 0xa2, 0xa2, 0x1d, 0xb6, 0x35, 0x19, 0x9b, 0xd9,
+ 0x5a, 0xa2, 0x5b, 0x96, 0xd1, 0xb4, 0x68, 0x00, 0xc0, 0x8c, 0x17, 0x50, 0x83,
+ 0x66, 0xbf, 0x83, 0x94, 0xd8, 0x46, 0x68,
+ ],
+ [
+ 0x9b, 0xd0, 0xb5, 0x2d, 0x27, 0x7f, 0x23, 0xa6, 0x32, 0xc2, 0xa8, 0x4a, 0x2d,
+ 0x61, 0x06, 0xae, 0x77, 0x63, 0x22, 0x14,
+ ],
+ [
+ 0xc2, 0x27, 0xd1, 0x71, 0x74, 0xf2, 0x4e, 0x1a, 0x98, 0x09, 0x1b, 0xb0, 0x2f,
+ 0xc0, 0x9f, 0xdf, 0x39, 0x0b, 0x60, 0x68, 0x37, 0x58, 0x21, 0x88, 0x0e, 0x58,
+ 0x46, 0x2b, 0x08, 0x99, 0xb8, 0x03,
+ ],
+ [
+ 0x31, 0xf2, 0xfd, 0xcd, 0x14, 0x19, 0x81, 0xe7, 0x29, 0x43, 0xbb, 0x27, 0xad,
+ 0x19, 0x17, 0x5a, 0xd4, 0xc4, 0x9d, 0x34, 0x0e, 0x6e, 0x74, 0xe4, 0x0f, 0xf4,
+ 0x0e, 0xb7, 0x19, 0xd7, 0xdc, 0x19, 0x89, 0xba, 0x2c, 0xe7, 0x8b, 0xed, 0xe8,
+ 0x10, 0x21, 0x15, 0x1d, 0x8b, 0x66, 0xdf, 0x37, 0x48,
+ ],
+ [
+ 0x1e, 0xd3, 0x26, 0xc3, 0xf3, 0x01, 0x12, 0x37, 0xdb, 0x2f, 0xd9, 0x33, 0x8d,
+ 0xb1, 0x3e, 0x7d, 0x50, 0xe4, 0xe8, 0xda, 0x8a, 0x5d, 0x4a, 0x02, 0xa3, 0x24,
+ 0xfc, 0x9d, 0x0e, 0x5e, 0x1b, 0x73, 0x97, 0x2a, 0xbd, 0xe3, 0x04, 0x6d, 0x54,
+ 0xcc, 0xd9, 0x67, 0xa5, 0xdf, 0x37, 0xc6, 0x6c, 0x9a, 0x2c, 0xb7, 0x12, 0x80,
+ 0x18, 0xd6, 0x94, 0x4a, 0xc1, 0x19, 0x7b, 0x4c, 0x26, 0x58, 0x12, 0x31,
+ ]
+ ),
+ test_case!(
+ [
+ 0xd7, 0x65, 0xb5, 0x5a, 0x5b, 0x5e, 0xe0, 0xd6, 0xda, 0x29, 0xcb, 0x42, 0xe1,
+ 0x2a, 0x89, 0x9f, 0x7f, 0x23, 0xaa, 0x27, 0xca, 0x30, 0xbf, 0x33, 0x48, 0x16,
+ 0x5c, 0x7c, 0x74, 0xe8, 0x92, 0x06, 0x75, 0x73, 0xd1, 0x55, 0xee, 0x73, 0x40,
+ 0xd2, 0xe9, 0xd0, 0x58, 0xc6, 0x1a, 0x2b, 0x00,
+ ],
+ [
+ 0xec, 0x56, 0xeb, 0x62, 0xb8, 0xa0, 0xe0, 0x57, 0xcc, 0x82, 0x3d, 0x82, 0xe9,
+ 0xc7, 0xa2, 0x2b, 0x1b, 0x61, 0xab, 0x16,
+ ],
+ [
+ 0xe1, 0x8d, 0x9d, 0xb0, 0x00, 0x61, 0x5c, 0x28, 0x09, 0x7a, 0xbe, 0xb6, 0x77,
+ 0xd8, 0xb4, 0xa7, 0x0b, 0x2f, 0xd1, 0xaf, 0x58, 0x69, 0xb3, 0xa1, 0x81, 0x03,
+ 0x87, 0xed, 0x69, 0x58, 0x89, 0xb0,
+ ],
+ [
+ 0x22, 0x06, 0xed, 0xa0, 0x52, 0xd5, 0x70, 0xef, 0xed, 0xe8, 0x56, 0xd0, 0x0d,
+ 0x53, 0x42, 0xdf, 0xd3, 0xfd, 0x0f, 0x0a, 0x17, 0x6b, 0x7b, 0x46, 0xef, 0xeb,
+ 0xda, 0x8a, 0x3c, 0xb4, 0x0b, 0xcf, 0x23, 0xb4, 0xde, 0xb9, 0x1d, 0x1a, 0x47,
+ 0x26, 0xa3, 0x3e, 0x3c, 0xb4, 0xbb, 0x23, 0xa1, 0xe7,
+ ],
+ [
+ 0x40, 0x6a, 0x54, 0x7c, 0x7d, 0x7a, 0x7d, 0x3f, 0xae, 0xaf, 0xba, 0x91, 0x3b,
+ 0xc0, 0x48, 0x58, 0x24, 0x29, 0x49, 0x57, 0x53, 0x32, 0xfe, 0xb9, 0x45, 0xfb,
+ 0xd6, 0x91, 0xef, 0xb5, 0x16, 0x94, 0x58, 0x14, 0x2a, 0xa2, 0x41, 0x61, 0x19,
+ 0x8a, 0x36, 0x04, 0x94, 0xd8, 0xdc, 0xdd, 0x8d, 0x0c, 0xc2, 0xef, 0x50, 0x11,
+ 0x17, 0x49, 0x6d, 0x58, 0x74, 0xb1, 0x9d, 0xfb, 0x43, 0x62, 0xde, 0x1f,
+ ]
+ ),
+ test_case!(
+ [
+ 0xe4, 0x88, 0xe3, 0x3d, 0xfc, 0x4a, 0x48, 0xd2, 0xf3, 0x7f, 0x1f, 0xa8, 0x47,
+ 0x20, 0x6e, 0x6e, 0x87, 0x20, 0x47, 0x78, 0x1d, 0xfb, 0x3c, 0x5c, 0xbb, 0xfb,
+ 0x5d, 0xb3, 0x5a, 0x92, 0x37, 0x57, 0x84, 0xef, 0x51, 0xc0, 0x29, 0x29, 0xd3,
+ 0x13, 0x6e, 0x42, 0x86, 0xef, 0x4e, 0x53, 0xd5, 0x54,
+ ],
+ [
+ 0xc5, 0x38, 0xe5, 0x28, 0x99, 0x0d, 0xbc, 0x8f, 0xec, 0x2c, 0x2d, 0x74, 0x9d,
+ 0x6c, 0x09, 0xce, 0xda, 0xda, 0x01, 0xe4,
+ ],
+ [
+ 0x7d, 0x1a, 0x96, 0x9b, 0xa1, 0x53, 0xdf, 0x51, 0x75, 0xad, 0xba, 0x2d, 0x85,
+ 0xe1, 0x80, 0xce, 0x61, 0xf4, 0x4d, 0x62, 0xf8, 0xe6, 0x7e, 0x1f, 0x57, 0x9f,
+ 0xa2, 0x27, 0x76, 0xbb, 0xd8, 0x27,
+ ],
+ [
+ 0x38, 0xf4, 0x61, 0xc0, 0x24, 0x5d, 0xd0, 0x99, 0x64, 0xc1, 0x93, 0xb5, 0x92,
+ 0x3c, 0x45, 0x15, 0x84, 0x91, 0x6c, 0x04, 0xaf, 0xae, 0x31, 0x10, 0x7f, 0x80,
+ 0x85, 0x3a, 0xd8, 0x32, 0x10, 0xb2, 0xef, 0x07, 0x16, 0x89, 0x6c, 0x35, 0x97,
+ 0x47, 0x3c, 0x81, 0xc3, 0x18, 0xfe, 0x47, 0xde, 0xd7,
+ ],
+ [
+ 0x5a, 0xe4, 0x2b, 0xca, 0x16, 0xb9, 0xe8, 0xc8, 0xe5, 0x89, 0x18, 0x15, 0x27,
+ 0x2f, 0x7c, 0x92, 0x21, 0x19, 0xb1, 0x28, 0x4b, 0x81, 0x09, 0xf4, 0x0d, 0x78,
+ 0x4f, 0xea, 0xe3, 0x30, 0x0a, 0x51, 0xc2, 0x0f, 0x8e, 0x42, 0xe5, 0x35, 0xde,
+ 0xb5, 0xd2, 0x94, 0x3f, 0x60, 0x02, 0x12, 0xec, 0x1f, 0x84, 0x6d, 0x82, 0xf4,
+ 0xf1, 0x06, 0xe9, 0xf0, 0x7b, 0xf7, 0x7a, 0x99, 0x68, 0x93, 0x19, 0x35,
+ ]
+ ),
+ test_case!(
+ [
+ 0xc2, 0x92, 0xa0, 0x25, 0xab, 0xe8, 0x7d, 0x53, 0x61, 0x66, 0x19, 0xf1, 0x5d,
+ 0xf5, 0x1b, 0xa6, 0x9c, 0x8d, 0x41, 0x3c, 0x05, 0x75, 0xdb, 0x45, 0x7e, 0x08,
+ 0x9e, 0x99, 0x31, 0x26, 0xf3, 0x5c, 0x84, 0x96, 0xa5, 0x20, 0x27, 0xac, 0xb0,
+ 0x89, 0xb4, 0x0d, 0x85, 0x00, 0xff, 0xc6, 0xe2, 0x00, 0x58,
+ ],
+ [
+ 0x7e, 0x9f, 0xa5, 0xf4, 0xf2, 0x9c, 0x6b, 0x2c, 0x87, 0x2f, 0xe1, 0x45, 0x51,
+ 0x82, 0xa1, 0x80, 0xec, 0xdb, 0x0e, 0x86,
+ ],
+ [
+ 0x58, 0x04, 0x1b, 0x6a, 0x8d, 0x73, 0xa3, 0x45, 0xb6, 0xed, 0x8f, 0x1b, 0x6a,
+ 0xef, 0x0b, 0x30, 0x5f, 0xec, 0x4b, 0xa3, 0x83, 0x17, 0x21, 0xb6, 0xb0, 0x79,
+ 0xac, 0x59, 0x2e, 0x8a, 0x67, 0x2d,
+ ],
+ [
+ 0x01, 0x5d, 0x3a, 0xf2, 0x62, 0xf0, 0x45, 0x3a, 0xf3, 0x93, 0x6e, 0x65, 0xb5,
+ 0x39, 0xa1, 0x2f, 0x76, 0x08, 0x9d, 0x1e, 0x8b, 0x51, 0xb0, 0xb7, 0x53, 0x5c,
+ 0xc8, 0x0e, 0xbe, 0x86, 0x61, 0x74, 0xc4, 0x55, 0x8b, 0xfd, 0xf1, 0xd5, 0x37,
+ 0x0d, 0xe6, 0xd9, 0x12, 0x31, 0xa3, 0xd8, 0x78, 0x06,
+ ],
+ [
+ 0x50, 0x6d, 0x1b, 0xb5, 0x95, 0xc2, 0x78, 0xe7, 0x9e, 0x94, 0x3e, 0x4e, 0xb0,
+ 0x63, 0x28, 0x46, 0x9c, 0x9b, 0x1f, 0xed, 0x99, 0x88, 0x34, 0x4f, 0xde, 0x11,
+ 0x98, 0xd8, 0xce, 0x72, 0xf7, 0xb4, 0x50, 0x26, 0x33, 0xe0, 0x1f, 0x1a, 0x37,
+ 0xeb, 0x56, 0x62, 0xaf, 0xbc, 0xa2, 0x0e, 0xf0, 0x02, 0x9a, 0xa1, 0xe9, 0x7b,
+ 0xbf, 0x34, 0xc1, 0x96, 0x52, 0xb1, 0x1d, 0x59, 0x65, 0x61, 0x66, 0xc0,
+ ]
+ ),
+ test_case!(
+ [
+ 0x97, 0xa9, 0xb4, 0x7b, 0x8b, 0xc3, 0x11, 0x0a, 0x34, 0x30, 0x56, 0x4a, 0xd2,
+ 0x6e, 0xe8, 0x4e, 0x06, 0xc9, 0x05, 0xbc, 0x8f, 0x52, 0x4a, 0x07, 0x4f, 0x2b,
+ 0x7a, 0x96, 0x0a, 0x51, 0x9e, 0xdb, 0x28, 0x7b, 0x40, 0xd7, 0x12, 0x08, 0x64,
+ 0xce, 0xf3, 0xf4, 0x1a, 0x9e, 0xb3, 0x03, 0x8d, 0xf7, 0xe9, 0x57,
+ ],
+ [
+ 0x65, 0x3d, 0x0d, 0xa5, 0x30, 0x2e, 0xd8, 0x1c, 0xe3, 0xf2, 0x96, 0x37, 0x06,
+ 0x74, 0x99, 0xae, 0x0f, 0x13, 0xbf, 0x6a,
+ ],
+ [
+ 0x18, 0x20, 0xd4, 0x9d, 0x02, 0x72, 0xeb, 0xa7, 0x9c, 0x36, 0x5c, 0x2c, 0x37,
+ 0xc9, 0x03, 0xeb, 0xcd, 0xed, 0x1e, 0xae, 0x46, 0x1d, 0xdf, 0x74, 0x21, 0x43,
+ 0x76, 0xfd, 0xaf, 0x16, 0xbf, 0x62,
+ ],
+ [
+ 0xef, 0x67, 0x3b, 0x92, 0x76, 0x44, 0xba, 0xaa, 0x47, 0x22, 0xe3, 0x4d, 0xe3,
+ 0xb9, 0xbd, 0xb8, 0x4a, 0x90, 0x7b, 0x62, 0xae, 0xec, 0x1c, 0x3a, 0x07, 0xd3,
+ 0x88, 0x69, 0xb4, 0x16, 0x46, 0x67, 0x94, 0xf3, 0x84, 0xe8, 0xd6, 0xef, 0xfb,
+ 0xf5, 0x2f, 0x74, 0xd2, 0xd9, 0x4e, 0x23, 0xeb, 0x56,
+ ],
+ [
+ 0x64, 0x54, 0x09, 0x73, 0x59, 0x36, 0x87, 0x48, 0x06, 0x48, 0xa3, 0xd8, 0x63,
+ 0x24, 0x7c, 0xbc, 0x38, 0x3a, 0x91, 0x2c, 0x88, 0xf3, 0x6b, 0x12, 0xea, 0x5f,
+ 0x6c, 0x03, 0x9f, 0x9c, 0xf3, 0x3e, 0xf0, 0x8c, 0x4b, 0x94, 0xc0, 0x50, 0xc9,
+ 0x33, 0x37, 0x61, 0x7e, 0xb6, 0x32, 0xbc, 0x26, 0xf7, 0xcc, 0x9c, 0x6e, 0x0e,
+ 0x49, 0xa8, 0x8d, 0x94, 0x88, 0x48, 0x75, 0xda, 0x1e, 0x34, 0x58, 0xe1,
+ ]
+ ),
+ test_case!(
+ [
+ 0xff, 0x53, 0xbe, 0x51, 0x7b, 0x99, 0xa3, 0xe8, 0xae, 0xcb, 0xc5, 0xc3, 0x61,
+ 0x8a, 0x86, 0x40, 0x2c, 0x11, 0xce, 0x0b, 0x28, 0x0a, 0x46, 0x2e, 0x2f, 0x60,
+ 0x46, 0xfe, 0x87, 0x58, 0xb6, 0x02, 0x07, 0xd9, 0x93, 0xb6, 0x9a, 0xa9, 0x8c,
+ 0xa1, 0x51, 0x8e, 0xe6, 0xf7, 0xa5, 0xe9, 0x23, 0xa5, 0x1e, 0x53, 0xbe,
+ ],
+ [
+ 0xd2, 0xf3, 0x99, 0x3d, 0xe2, 0x0e, 0x79, 0xf7, 0x9c, 0xf3, 0x0e, 0x46, 0x09,
+ 0x14, 0xbc, 0xe9, 0x9f, 0x6f, 0x78, 0xab,
+ ],
+ [
+ 0x0a, 0xce, 0xda, 0xbb, 0xdd, 0x56, 0x73, 0x22, 0x71, 0x11, 0xc2, 0xed, 0xf4,
+ 0x14, 0xb5, 0x47, 0xef, 0x17, 0x9d, 0x2b, 0x42, 0x83, 0x9c, 0xc1, 0x4d, 0x3a,
+ 0x12, 0x88, 0x83, 0x00, 0x0a, 0x6d,
+ ],
+ [
+ 0x78, 0x56, 0xc6, 0xa6, 0xc8, 0xec, 0x80, 0x97, 0x13, 0xc4, 0xdd, 0x12, 0x13,
+ 0x5c, 0xbe, 0xf8, 0x61, 0x83, 0xfe, 0xd6, 0xc7, 0x7d, 0x92, 0x1e, 0xb5, 0x88,
+ 0x10, 0x1b, 0x6e, 0x4c, 0x15, 0x65, 0x86, 0xf5, 0x30, 0x50, 0x99, 0x52, 0xec,
+ 0x3b, 0x06, 0x3e, 0x0c, 0xf7, 0x98, 0x96, 0x98, 0xe5,
+ ],
+ [
+ 0xd9, 0x03, 0x61, 0xeb, 0xb1, 0x1f, 0x9a, 0x6f, 0xac, 0x9b, 0x06, 0x83, 0xb2,
+ 0xe0, 0x0a, 0xc7, 0xe0, 0x4e, 0x35, 0x24, 0xa9, 0xfa, 0xcf, 0x91, 0xaa, 0x67,
+ 0x0b, 0xf4, 0x39, 0x72, 0x06, 0x6f, 0x31, 0xfb, 0x3a, 0x8e, 0xb6, 0xc0, 0xc1,
+ 0x32, 0x45, 0x0e, 0x95, 0xe6, 0x76, 0xff, 0x6f, 0x2d, 0x14, 0xa8, 0x41, 0xb1,
+ 0x6c, 0x62, 0xa0, 0x1d, 0x08, 0x21, 0x55, 0xfa, 0x70, 0xc2, 0xad, 0xa3,
+ ]
+ ),
+ test_case!(
+ [
+ 0x61, 0x0c, 0x7d, 0x86, 0x5d, 0x4d, 0x99, 0x39, 0x8d, 0x5f, 0x8b, 0x22, 0x3b,
+ 0xac, 0x73, 0xd0, 0xb3, 0x22, 0x8e, 0x46, 0x05, 0xf9, 0xa2, 0xd9, 0x97, 0xfd,
+ 0x62, 0xff, 0x9f, 0x5b, 0x87, 0x80, 0x4d, 0x5c, 0x1e, 0x52, 0xdd, 0xbe, 0xa4,
+ 0x31, 0x7b, 0x65, 0x87, 0xa5, 0xde, 0x19, 0x35, 0x72, 0x82, 0x48, 0x1c, 0x3d,
+ ],
+ [
+ 0x51, 0x15, 0xc7, 0xbe, 0x1c, 0x2d, 0x88, 0x8a, 0xe2, 0xf5, 0xd5, 0xf3, 0x1e,
+ 0x46, 0x3d, 0x21, 0x67, 0x43, 0xe3, 0xf2,
+ ],
+ [
+ 0x5e, 0xdf, 0x62, 0x80, 0x40, 0xfe, 0xd0, 0xf3, 0x3a, 0xe0, 0x47, 0x0d, 0xac,
+ 0xd4, 0xba, 0x7a, 0x03, 0xa3, 0xbb, 0x7b, 0x62, 0xd8, 0xe5, 0x85, 0xdc, 0x33,
+ 0x7d, 0x52, 0xdd, 0x47, 0x79, 0x31,
+ ],
+ [
+ 0x88, 0xb8, 0x6c, 0x4f, 0x55, 0xc9, 0x92, 0x2c, 0x9e, 0x49, 0x81, 0xfa, 0x0a,
+ 0x9f, 0x86, 0x45, 0xde, 0x17, 0x13, 0x48, 0x25, 0x3b, 0x23, 0x63, 0x19, 0xfe,
+ 0x1f, 0x0c, 0xd9, 0x22, 0x07, 0x0a, 0xa9, 0x65, 0x08, 0x8e, 0xd7, 0x38, 0x1a,
+ 0x07, 0xe4, 0xa8, 0x84, 0x28, 0x53, 0x8c, 0xae, 0x4d,
+ ],
+ [
+ 0xa4, 0x3d, 0xa7, 0xcf, 0x66, 0xd6, 0xf8, 0xfc, 0xba, 0x52, 0xc9, 0xf8, 0x77,
+ 0xfc, 0xe8, 0x3b, 0xf2, 0xab, 0x3d, 0xc2, 0x05, 0x20, 0xdd, 0x88, 0xd9, 0x45,
+ 0x7d, 0xa1, 0x5f, 0x02, 0x45, 0x59, 0xcf, 0x1b, 0x97, 0xd4, 0x99, 0xcb, 0x93,
+ 0xe6, 0xbc, 0xa1, 0x34, 0xe6, 0x38, 0x04, 0x7b, 0x20, 0x0d, 0x52, 0x3d, 0xbc,
+ 0x8a, 0xa4, 0xd5, 0x36, 0x05, 0x70, 0xc2, 0x5a, 0xea, 0x09, 0x29, 0x54,
+ ]
+ ),
+ test_case!(
+ [
+ 0xec, 0x74, 0x36, 0x9a, 0x3c, 0x0e, 0xd7, 0xd2, 0xff, 0x1e, 0x05, 0x1d, 0x15,
+ 0xa8, 0x9e, 0x29, 0x2b, 0x19, 0x03, 0x41, 0xe8, 0x22, 0x5a, 0xdf, 0x8a, 0xe5,
+ 0xdb, 0x1f, 0xe3, 0x85, 0xcf, 0x0e, 0x48, 0x6c, 0xbd, 0x37, 0x69, 0x8e, 0x20,
+ 0x46, 0xa2, 0x5b, 0xc9, 0xac, 0x2a, 0x0a, 0xed, 0xf8, 0x78, 0x88, 0xc5, 0x4f,
+ 0xf8,
+ ],
+ [
+ 0x87, 0x01, 0x7f, 0x76, 0x59, 0xd1, 0xf4, 0xff, 0x53, 0x2f, 0x96, 0xae, 0x63,
+ 0x92, 0xfa, 0x8e, 0x2d, 0x88, 0xd1, 0x41,
+ ],
+ [
+ 0xd4, 0xc7, 0x60, 0x1b, 0x89, 0x30, 0x31, 0x58, 0xa9, 0x14, 0x89, 0x42, 0x24,
+ 0x1f, 0xbd, 0x68, 0x32, 0xbb, 0x0b, 0x27, 0xd1, 0x4c, 0x6c, 0x53, 0xec, 0xd7,
+ 0xf5, 0x30, 0x51, 0xec, 0xa8, 0xa6,
+ ],
+ [
+ 0x3c, 0x7f, 0x55, 0x0a, 0x9c, 0x30, 0xbc, 0x67, 0x33, 0x30, 0x86, 0xca, 0x67,
+ 0x79, 0xe4, 0xac, 0xd8, 0xe2, 0x79, 0xb8, 0xcb, 0x7c, 0x12, 0x99, 0x93, 0xb3,
+ 0x75, 0x4d, 0x8c, 0xca, 0xa5, 0x24, 0x13, 0x6f, 0x87, 0xe7, 0xe1, 0xcf, 0x3f,
+ 0xeb, 0x5f, 0x5f, 0x03, 0xee, 0xbe, 0xee, 0x80, 0xce,
+ ],
+ [
+ 0x68, 0x1b, 0x4e, 0xb4, 0x22, 0x92, 0x2c, 0x01, 0xf1, 0x05, 0xf4, 0xc7, 0xcb,
+ 0x05, 0xef, 0x6c, 0x68, 0x89, 0x7e, 0x09, 0xc2, 0x14, 0xf2, 0x59, 0x12, 0x67,
+ 0x6e, 0x29, 0x13, 0xad, 0xeb, 0x10, 0x35, 0x16, 0x10, 0x8d, 0xaf, 0x9a, 0x3d,
+ 0xa6, 0x60, 0xed, 0x21, 0xa3, 0x19, 0xf4, 0xa8, 0x66, 0xfe, 0xdf, 0x5d, 0x30,
+ 0xbe, 0xa9, 0x6f, 0xc0, 0x8c, 0x0c, 0x87, 0xed, 0x90, 0x20, 0x3c, 0x47,
+ ]
+ ),
+ test_case!(
+ [
+ 0x29, 0xca, 0x22, 0xbe, 0xf4, 0xe4, 0x52, 0x62, 0x90, 0xe1, 0xac, 0xcd, 0x4b,
+ 0x7c, 0x14, 0x75, 0xa6, 0x6a, 0x30, 0x13, 0xe6, 0x71, 0xf0, 0x32, 0xd9, 0x85,
+ 0xbd, 0x6a, 0x9a, 0xcf, 0x65, 0x16, 0xff, 0x42, 0x7c, 0x35, 0xca, 0x0d, 0x19,
+ 0xa9, 0x5b, 0x88, 0x3f, 0x99, 0xc4, 0x76, 0xbd, 0x97, 0x06, 0x6f, 0x50, 0x92,
+ 0x27, 0xc7,
+ ],
+ [
+ 0x86, 0x5a, 0x7d, 0xb7, 0x49, 0x66, 0x63, 0x4a, 0x1c, 0xd3, 0xa2, 0xce, 0x90,
+ 0x3d, 0x26, 0x93, 0x25, 0x70, 0x67, 0x6a,
+ ],
+ [
+ 0x7b, 0x72, 0xae, 0x69, 0xf5, 0x2f, 0xd0, 0xd1, 0x40, 0xdf, 0x57, 0x3b, 0xe0,
+ 0x47, 0xfd, 0xf9, 0xfd, 0x0d, 0xd0, 0xf1, 0x6d, 0x32, 0xcb, 0x3b, 0xd8, 0x38,
+ 0x90, 0xfe, 0x17, 0xcf, 0xa0, 0x70,
+ ],
+ [
+ 0x35, 0x9f, 0x16, 0xcc, 0x64, 0x78, 0x4e, 0xb9, 0x2a, 0xe5, 0x9d, 0x6e, 0xb6,
+ 0x8f, 0xe3, 0x74, 0xb8, 0x8b, 0xc3, 0x0e, 0x42, 0xfd, 0x5f, 0x57, 0x57, 0x6d,
+ 0xf1, 0x9c, 0xb3, 0xe5, 0xfa, 0x0f, 0x53, 0x2d, 0x03, 0x2a, 0xea, 0x59, 0x21,
+ 0xe4, 0x3d, 0x76, 0x06, 0xb9, 0xa5, 0x9e, 0xe4, 0xee,
+ ],
+ [
+ 0x7c, 0x95, 0x28, 0x3a, 0xf4, 0xe2, 0x34, 0xaf, 0x61, 0xa7, 0xf2, 0x12, 0xad,
+ 0xe6, 0x28, 0x8f, 0xb2, 0x76, 0x2b, 0x1c, 0xdb, 0xea, 0x90, 0x3c, 0x5a, 0x56,
+ 0x46, 0x93, 0x0d, 0xe8, 0x5d, 0x9f, 0x9a, 0x90, 0xd8, 0x8f, 0xd9, 0x10, 0xdf,
+ 0x02, 0x81, 0xfc, 0x8f, 0x8f, 0xb5, 0x8b, 0xd4, 0x61, 0xa0, 0x97, 0x69, 0x0e,
+ 0x4e, 0xef, 0x77, 0x47, 0xd3, 0x12, 0x6c, 0xa8, 0x45, 0x95, 0xd2, 0x51,
+ ]
+ ),
+ test_case!(
+ [
+ 0x50, 0xca, 0xc8, 0x7a, 0x60, 0x00, 0x81, 0x01, 0x45, 0xef, 0x41, 0x14, 0x80,
+ 0x0c, 0x30, 0xcc, 0x2a, 0xf8, 0x98, 0xa3, 0x8e, 0x21, 0x46, 0x04, 0x99, 0xad,
+ 0xe2, 0x6a, 0x8e, 0xb3, 0x4b, 0xfa, 0x14, 0x55, 0x07, 0xba, 0x3b, 0x82, 0x6b,
+ 0x10, 0x88, 0x83, 0xd9, 0xe6, 0x59, 0x00, 0x19, 0xc3, 0xb6, 0x03, 0xaf, 0x36,
+ 0x0c, 0x7c, 0xf1,
+ ],
+ [
+ 0x86, 0xbd, 0xc1, 0xb1, 0x4f, 0xa2, 0x22, 0x77, 0x67, 0x99, 0x10, 0x4c, 0x11,
+ 0x34, 0xf0, 0xbf, 0x9e, 0x24, 0x8b, 0x07,
+ ],
+ [
+ 0xf5, 0xf3, 0x26, 0xf2, 0xb4, 0x56, 0x9c, 0xbe, 0x79, 0xce, 0xb3, 0x2a, 0x8f,
+ 0xa7, 0x4a, 0x94, 0x2b, 0xb6, 0x3d, 0x03, 0x97, 0xf4, 0xd9, 0xa7, 0x84, 0x7d,
+ 0x6a, 0xd2, 0x77, 0x58, 0xc1, 0x61,
+ ],
+ [
+ 0x74, 0xc1, 0x48, 0x8f, 0x66, 0xa0, 0x31, 0x81, 0x6f, 0x9c, 0xf5, 0x2e, 0xf5,
+ 0xe2, 0x15, 0x88, 0x74, 0x9a, 0xec, 0xb0, 0x83, 0xa7, 0xaf, 0x2c, 0x2c, 0xc3,
+ 0xe0, 0x5a, 0x0f, 0xd3, 0xde, 0x5d, 0x52, 0xfc, 0x0c, 0x79, 0x51, 0x68, 0xe4,
+ 0xab, 0xea, 0x3a, 0x37, 0x98, 0x3e, 0xa7, 0x20, 0x4c,
+ ],
+ [
+ 0x97, 0x94, 0x7d, 0xdc, 0x72, 0xd7, 0x3e, 0x46, 0x33, 0xaf, 0x91, 0xf2, 0x77,
+ 0xc3, 0xc4, 0xb4, 0x90, 0xfe, 0xd7, 0x51, 0xf0, 0xd0, 0x3b, 0x9b, 0x3f, 0x33,
+ 0xf4, 0x71, 0xe5, 0xb1, 0x7a, 0x2e, 0x9c, 0x12, 0x40, 0x8f, 0x2b, 0x3e, 0x04,
+ 0xac, 0x51, 0x38, 0xaa, 0x36, 0xcd, 0x34, 0x97, 0x49, 0x9f, 0xc3, 0x1f, 0x22,
+ 0xdb, 0x86, 0x3e, 0x43, 0x84, 0xa3, 0x90, 0x19, 0x37, 0x04, 0x53, 0x30,
+ ]
+ ),
+ test_case!(
+ [
+ 0x20, 0xbc, 0x2a, 0xaf, 0xb9, 0x23, 0x16, 0x8f, 0x54, 0x8f, 0xd3, 0xc5, 0xd5,
+ 0xe2, 0xc2, 0xb0, 0xde, 0x68, 0x0e, 0xf0, 0xe5, 0xd9, 0x7d, 0xb7, 0x6b, 0xc5,
+ 0xc2, 0x0d, 0x65, 0xe6, 0x87, 0x96, 0x8d, 0xbc, 0xd0, 0x2f, 0x88, 0x6f, 0x21,
+ 0xaa, 0xcc, 0x20, 0xa0, 0x4a, 0x10, 0xc7, 0x80, 0x85, 0xb2, 0x1e, 0xe3, 0x24,
+ 0x58, 0x0c, 0xc0, 0x0b,
+ ],
+ [
+ 0x64, 0xe5, 0x27, 0x82, 0xf5, 0xf1, 0x58, 0x51, 0xee, 0xe6, 0x1a, 0xa7, 0x73,
+ 0x3c, 0x84, 0x38, 0xdf, 0xaf, 0xf8, 0xd0,
+ ],
+ [
+ 0x6e, 0x96, 0x3f, 0x78, 0x6d, 0x06, 0x98, 0xfb, 0x25, 0x9e, 0xcc, 0xdd, 0x59,
+ 0xd5, 0x9e, 0xe5, 0xbf, 0x47, 0x77, 0xbb, 0xbd, 0x9f, 0xe0, 0x5f, 0xe9, 0x48,
+ 0x4c, 0x90, 0xcc, 0x13, 0x06, 0x9c,
+ ],
+ [
+ 0x2c, 0x59, 0xb4, 0x84, 0x6f, 0x41, 0xa3, 0x3c, 0xcd, 0xf5, 0x97, 0x79, 0xaa,
+ 0x5d, 0xfb, 0x5e, 0xaf, 0x97, 0x2f, 0xa1, 0xdb, 0xc6, 0x69, 0x7d, 0xf4, 0x6c,
+ 0xb7, 0xee, 0x5a, 0xd3, 0xff, 0x52, 0xbe, 0x01, 0xbc, 0x3e, 0xe7, 0x69, 0xc0,
+ 0xd4, 0xfe, 0xd2, 0xf2, 0x22, 0x53, 0xa1, 0xc1, 0x31,
+ ],
+ [
+ 0x97, 0x02, 0x97, 0xd2, 0xd6, 0x68, 0x25, 0x7a, 0x06, 0x4f, 0x0e, 0xb5, 0xb2,
+ 0x70, 0xcf, 0x4d, 0x62, 0xc2, 0x87, 0xa1, 0x0d, 0xea, 0x8a, 0x28, 0x48, 0x7c,
+ 0x56, 0x9c, 0x10, 0xb1, 0x70, 0x33, 0xeb, 0x13, 0xda, 0xf7, 0x6c, 0xfc, 0x30,
+ 0xfa, 0x58, 0xfc, 0x7c, 0x2c, 0x8d, 0x5d, 0x3c, 0x5d, 0x9a, 0x0e, 0x5f, 0xa6,
+ 0x0c, 0x75, 0xf2, 0xad, 0x5a, 0x0b, 0xc8, 0xe3, 0x14, 0x4c, 0xbb, 0xed,
+ ]
+ ),
+ test_case!(
+ [
+ 0x5f, 0xb2, 0x24, 0x70, 0xc4, 0xb6, 0x8b, 0x3e, 0xad, 0x17, 0x09, 0x72, 0x43,
+ 0x76, 0x26, 0x64, 0x03, 0xbd, 0xba, 0xd7, 0x2a, 0x1a, 0x36, 0x72, 0x70, 0xf3,
+ 0xff, 0xb7, 0xf5, 0x4e, 0x1a, 0x2d, 0x86, 0xdf, 0xac, 0x6e, 0x14, 0xe1, 0xbe,
+ 0xa4, 0x9c, 0x91, 0x21, 0x3d, 0x14, 0x69, 0x8b, 0xf4, 0x93, 0x2f, 0x13, 0x8c,
+ 0x7a, 0x7d, 0xf5, 0xf8, 0x0f,
+ ],
+ [
+ 0x62, 0xe5, 0xa2, 0xbc, 0xb9, 0x1e, 0x86, 0xb4, 0x4e, 0x25, 0xb2, 0x49, 0x67,
+ 0x4f, 0xcd, 0x36, 0x24, 0x40, 0x76, 0xa2,
+ ],
+ [
+ 0x64, 0x74, 0xbb, 0xb7, 0x8b, 0x45, 0x29, 0x20, 0xe4, 0x21, 0x31, 0xa3, 0x47,
+ 0x82, 0x5c, 0x94, 0xd4, 0x44, 0x7b, 0x6e, 0x8b, 0xb1, 0x84, 0x30, 0x5d, 0x96,
+ 0xc4, 0xb7, 0xa8, 0x3a, 0xa7, 0x91,
+ ],
+ [
+ 0x27, 0x25, 0xb7, 0xff, 0x9d, 0x09, 0x11, 0x22, 0xdf, 0xf3, 0xf4, 0x57, 0x67,
+ 0xa3, 0x93, 0x86, 0xba, 0x15, 0x76, 0x89, 0x5f, 0xb0, 0x03, 0x42, 0xa6, 0x11,
+ 0x51, 0xa8, 0x4a, 0x9e, 0x86, 0xa0, 0x73, 0xe8, 0x3a, 0xd5, 0xed, 0xa0, 0x95,
+ 0x99, 0x43, 0xd9, 0x85, 0x72, 0xaf, 0xcb, 0x88, 0xaa,
+ ],
+ [
+ 0xfb, 0x13, 0xfc, 0xf5, 0x7e, 0x63, 0xe4, 0xb7, 0x6a, 0x2f, 0xce, 0xcc, 0x0d,
+ 0xbf, 0x57, 0xc9, 0xf8, 0xc6, 0xab, 0x94, 0x8d, 0x66, 0xff, 0x40, 0x8b, 0x45,
+ 0x8e, 0x05, 0xdf, 0x6b, 0x3f, 0x60, 0x29, 0x83, 0x2b, 0xf4, 0x7a, 0x68, 0xcd,
+ 0x0f, 0x41, 0x59, 0x0a, 0x25, 0x84, 0x58, 0xe5, 0xec, 0xf1, 0xe9, 0x81, 0xbf,
+ 0x26, 0xa6, 0xd7, 0x91, 0x01, 0xe7, 0xa5, 0x9d, 0xdc, 0xc5, 0x21, 0x4f,
+ ]
+ ),
+ test_case!(
+ [
+ 0xf6, 0x33, 0x42, 0x41, 0xf8, 0xc6, 0xb4, 0x60, 0x03, 0xab, 0xf8, 0xbc, 0x91,
+ 0x81, 0xd4, 0x3d, 0xee, 0x63, 0x6e, 0xc2, 0x22, 0xe2, 0x33, 0xd4, 0x65, 0xe5,
+ 0xde, 0x61, 0x2c, 0x70, 0xf7, 0x6e, 0x1d, 0x32, 0x12, 0xa1, 0x82, 0xd9, 0x2b,
+ 0x84, 0x48, 0x1b, 0xc5, 0x7a, 0x2b, 0xb4, 0x56, 0xd7, 0x4e, 0x56, 0x81, 0xc0,
+ 0x25, 0x64, 0xd1, 0xad, 0x25, 0x48,
+ ],
+ [
+ 0xb7, 0x57, 0x56, 0x3a, 0x41, 0x55, 0x28, 0x19, 0xfb, 0x80, 0x3f, 0x52, 0x7b,
+ 0xa2, 0x05, 0x74, 0x3a, 0xaa, 0x0a, 0x21,
+ ],
+ [
+ 0x34, 0x54, 0x22, 0xa3, 0xdf, 0xe0, 0xc1, 0x3d, 0x33, 0x48, 0xa9, 0x1e, 0x73,
+ 0xa8, 0xa4, 0xb0, 0x8c, 0x67, 0x59, 0xf7, 0x71, 0x64, 0xd7, 0xa2, 0x5b, 0xee,
+ 0x62, 0xbf, 0x09, 0x87, 0x42, 0xe5,
+ ],
+ [
+ 0x57, 0xf2, 0x6e, 0x96, 0xc5, 0xac, 0x42, 0xed, 0x26, 0x54, 0xca, 0x94, 0xf6,
+ 0x26, 0x18, 0x1f, 0x5a, 0xa8, 0xe6, 0x24, 0x3a, 0xce, 0xf0, 0x46, 0x26, 0x20,
+ 0x2c, 0x81, 0x80, 0x1a, 0xdd, 0xaf, 0x62, 0x38, 0xda, 0xc3, 0x88, 0xab, 0xdb,
+ 0xbf, 0x55, 0xf2, 0x98, 0x31, 0xfa, 0x0a, 0x2a, 0xaf,
+ ],
+ [
+ 0x53, 0x78, 0xd7, 0x87, 0xb3, 0xce, 0xd4, 0x05, 0xf3, 0x8a, 0x5c, 0xe2, 0x27,
+ 0x44, 0xd7, 0x99, 0xb1, 0x1d, 0x53, 0x6f, 0xde, 0x76, 0xe0, 0x24, 0xce, 0xd0,
+ 0x0a, 0xd4, 0x3f, 0x04, 0xe7, 0x79, 0xa0, 0xae, 0x8a, 0xd5, 0xdf, 0x21, 0xd5,
+ 0x8b, 0x9a, 0xaf, 0x31, 0xbc, 0x9c, 0xe6, 0x25, 0x44, 0xab, 0x89, 0xae, 0x50,
+ 0xd0, 0xab, 0x23, 0x4b, 0xbf, 0x0f, 0x81, 0x72, 0x06, 0x95, 0x38, 0xad,
+ ]
+ ),
+ test_case!(
+ [
+ 0xa2, 0x36, 0x7a, 0x6e, 0xd0, 0x14, 0x71, 0xad, 0xb3, 0x36, 0x4b, 0xdb, 0x25,
+ 0xb2, 0xfe, 0x88, 0x53, 0x21, 0x43, 0xec, 0x0c, 0xc3, 0x69, 0x0b, 0xb7, 0xd8,
+ 0x41, 0x78, 0xd9, 0x97, 0x7c, 0x21, 0x44, 0x21, 0x40, 0xfe, 0x51, 0xba, 0x98,
+ 0x5a, 0x92, 0x7a, 0x54, 0x63, 0xca, 0x1a, 0x2b, 0x69, 0xbe, 0x16, 0x99, 0x8b,
+ 0x71, 0x2b, 0x4f, 0x18, 0xb4, 0xf2, 0x10,
+ ],
+ [
+ 0xdc, 0x41, 0xf9, 0x2c, 0xf3, 0xee, 0xf1, 0xa1, 0x81, 0x14, 0x0c, 0xeb, 0x48,
+ 0xa5, 0x27, 0x32, 0xb7, 0x58, 0xef, 0xdb,
+ ],
+ [
+ 0x6f, 0xa6, 0x84, 0x6f, 0x36, 0x78, 0x18, 0x77, 0xb0, 0x60, 0x31, 0x19, 0x61,
+ 0x6e, 0xd6, 0x2d, 0x46, 0x59, 0xbc, 0x50, 0xf7, 0x1d, 0x7a, 0x12, 0x5b, 0xb6,
+ 0xbc, 0x8b, 0xe8, 0x70, 0xba, 0x93,
+ ],
+ [
+ 0x70, 0x0c, 0x87, 0xa8, 0xc2, 0xdf, 0xdf, 0x43, 0x55, 0x25, 0xd3, 0x95, 0x01,
+ 0x45, 0x20, 0x6a, 0x4c, 0xf2, 0x95, 0x69, 0x93, 0x59, 0x9c, 0x35, 0x7b, 0xea,
+ 0x22, 0x81, 0x85, 0x41, 0xff, 0xa9, 0xcd, 0x2d, 0xbe, 0xd2, 0x82, 0x41, 0x0b,
+ 0x08, 0x3c, 0xca, 0x8e, 0x18, 0xcd, 0x48, 0x27, 0x3f,
+ ],
+ [
+ 0x44, 0xd2, 0xc1, 0x58, 0xd8, 0x7e, 0xbb, 0x23, 0x44, 0xe7, 0x0e, 0x4f, 0xe2,
+ 0x7c, 0xa8, 0x55, 0xca, 0xc6, 0x94, 0x61, 0xbb, 0x4f, 0x38, 0x29, 0x54, 0x1c,
+ 0x01, 0x0f, 0xe3, 0xa9, 0x4a, 0xa7, 0x11, 0xb2, 0xe9, 0x59, 0xae, 0x1b, 0x83,
+ 0x13, 0xf3, 0x47, 0xce, 0xe8, 0xc4, 0x24, 0xc1, 0x3e, 0x12, 0x79, 0x4a, 0x6c,
+ 0x27, 0x9e, 0xb7, 0xe1, 0xc7, 0x13, 0x4d, 0xf5, 0x70, 0x0e, 0x32, 0x1e,
+ ]
+ ),
+ test_case!(
+ [
+ 0xa8, 0x58, 0x76, 0x2a, 0x62, 0xa3, 0x3a, 0xf3, 0x49, 0x3f, 0x6a, 0x55, 0x81,
+ 0xfa, 0x2c, 0x81, 0xb3, 0xac, 0x1c, 0xa0, 0x19, 0x1b, 0x2f, 0x8d, 0x54, 0xa4,
+ 0x7a, 0x7a, 0xa0, 0xea, 0x3b, 0x27, 0xde, 0x8b, 0xf4, 0xef, 0x1f, 0xee, 0xb2,
+ 0x12, 0xa0, 0x31, 0x8f, 0xba, 0x26, 0xdf, 0xbf, 0xa4, 0x08, 0x44, 0x65, 0x52,
+ 0x56, 0x1d, 0xcf, 0xf2, 0x4e, 0x32, 0x1a, 0x2a,
+ ],
+ [
+ 0xb6, 0xfb, 0x3e, 0xf4, 0x66, 0x67, 0x09, 0xcb, 0x77, 0x77, 0x01, 0xb8, 0x7b,
+ 0x82, 0x45, 0x67, 0x13, 0x31, 0x48, 0xe2,
+ ],
+ [
+ 0x71, 0x90, 0x7c, 0x71, 0x9c, 0x32, 0x30, 0x9d, 0x31, 0x08, 0x1c, 0x6f, 0x9a,
+ 0x9a, 0x2d, 0xe5, 0x6e, 0xca, 0x4d, 0xca, 0x8c, 0xdf, 0x44, 0xc3, 0x2f, 0x4a,
+ 0x51, 0xc6, 0xb8, 0xff, 0x7e, 0xc5,
+ ],
+ [
+ 0xdf, 0x3e, 0x25, 0x42, 0x7a, 0xdf, 0x93, 0xfc, 0xca, 0x5a, 0x5c, 0x1e, 0x13,
+ 0x67, 0x82, 0xa2, 0x1b, 0xe4, 0x7c, 0x65, 0xd4, 0xbd, 0xa8, 0x69, 0x5d, 0xbe,
+ 0xd1, 0x2a, 0x2a, 0x1f, 0x14, 0xf8, 0xb1, 0x48, 0x63, 0xd3, 0x7d, 0x4f, 0x7c,
+ 0x75, 0x32, 0x57, 0x30, 0x03, 0x9e, 0x4b, 0x1a, 0x82,
+ ],
+ [
+ 0x67, 0x91, 0x7f, 0xa9, 0x0f, 0x7f, 0x97, 0xfd, 0xb1, 0x4e, 0x1b, 0x9e, 0xb0,
+ 0x8a, 0xe1, 0x99, 0xa5, 0x63, 0x3d, 0xbf, 0xf6, 0xa5, 0x1e, 0xa7, 0xfc, 0x78,
+ 0x68, 0x7a, 0x61, 0x76, 0xe1, 0xe5, 0x70, 0xc0, 0x3f, 0xf6, 0x20, 0x7e, 0xa4,
+ 0xfb, 0x66, 0x20, 0xb0, 0xe1, 0x96, 0xe2, 0xc2, 0x86, 0xf5, 0xf6, 0x8a, 0x8b,
+ 0xe2, 0xdf, 0x80, 0xc8, 0x2d, 0x61, 0x31, 0x11, 0xdc, 0x76, 0xb8, 0x8a,
+ ]
+ ),
+ test_case!(
+ [
+ 0x90, 0xc0, 0xec, 0x8d, 0x9d, 0x67, 0x58, 0x2a, 0xcd, 0x3d, 0x35, 0xd6, 0xc8,
+ 0x14, 0xc4, 0x51, 0x97, 0xe2, 0x04, 0x6d, 0xb3, 0xa1, 0xa9, 0xc1, 0x11, 0xac,
+ 0x28, 0xf3, 0xd3, 0xa7, 0x0e, 0xac, 0xc7, 0xb6, 0x2a, 0xa1, 0x82, 0x12, 0x68,
+ 0xf5, 0x55, 0x1a, 0x16, 0xbb, 0xa3, 0xfe, 0x9a, 0x59, 0x5c, 0x15, 0x01, 0xca,
+ 0x59, 0xb1, 0x23, 0x89, 0xce, 0x20, 0x17, 0x91, 0xd1,
+ ],
+ [
+ 0x2d, 0xa7, 0x9e, 0x20, 0x76, 0x0c, 0x76, 0x51, 0x16, 0x6c, 0x12, 0x99, 0xd0,
+ 0xcc, 0x49, 0x35, 0x32, 0xb2, 0x64, 0xde,
+ ],
+ [
+ 0x31, 0x39, 0xa5, 0x31, 0xa9, 0xa4, 0xc0, 0xce, 0x67, 0x57, 0x6f, 0x64, 0x6e,
+ 0x49, 0x07, 0xf6, 0x4a, 0x73, 0x9e, 0xfb, 0x98, 0xba, 0x73, 0x4f, 0x2c, 0x48,
+ 0x98, 0x88, 0xb8, 0x1a, 0xb0, 0x75,
+ ],
+ [
+ 0xe1, 0xe1, 0x4c, 0xaa, 0x5a, 0x1a, 0xdd, 0xc4, 0x7f, 0x42, 0xa9, 0x4c, 0xf0,
+ 0xef, 0xe4, 0x08, 0x8b, 0xdd, 0x4d, 0xce, 0x3a, 0xac, 0x38, 0x7d, 0x6d, 0xdd,
+ 0x52, 0x1c, 0x8b, 0x69, 0x30, 0x92, 0x78, 0xd7, 0x64, 0x15, 0x3a, 0x5f, 0x35,
+ 0xc7, 0x3e, 0x85, 0x45, 0x65, 0x25, 0x49, 0xf3, 0x67,
+ ],
+ [
+ 0x02, 0x87, 0x8d, 0xb1, 0x16, 0xc5, 0x03, 0xcf, 0xb4, 0xfe, 0x0d, 0xb8, 0x96,
+ 0xfd, 0xbb, 0xa7, 0x29, 0x7f, 0x82, 0x95, 0xf7, 0xa0, 0x31, 0xf5, 0xb8, 0x7b,
+ 0x2f, 0x4d, 0x99, 0x2f, 0x65, 0x33, 0x0a, 0x33, 0x79, 0x52, 0xc6, 0x1a, 0xdb,
+ 0x3c, 0x3b, 0xa9, 0x50, 0x09, 0x38, 0x59, 0xc5, 0x98, 0xb4, 0xa4, 0x3a, 0x79,
+ 0x01, 0x41, 0xb5, 0xf5, 0x08, 0x91, 0xf2, 0x66, 0xdf, 0x40, 0x34, 0x60,
+ ]
+ ),
+ test_case!(
+ [
+ 0xdd, 0x85, 0xa8, 0x2e, 0x98, 0x6d, 0x1d, 0x87, 0x67, 0x99, 0xef, 0x88, 0x22,
+ 0xc6, 0xc9, 0xc4, 0x49, 0x8e, 0x62, 0x44, 0x25, 0xa9, 0x1a, 0x86, 0x8a, 0xaa,
+ 0x98, 0x38, 0x87, 0xab, 0x1d, 0xa1, 0xed, 0x14, 0x24, 0x41, 0x42, 0xc6, 0xf3,
+ 0xbc, 0x76, 0xe2, 0xf4, 0xe5, 0x60, 0x10, 0x48, 0xf6, 0x60, 0x42, 0x10, 0x05,
+ 0x05, 0xc5, 0x46, 0x35, 0x5d, 0xdf, 0x9f, 0x34, 0xaa, 0xc2,
+ ],
+ [
+ 0xdc, 0xb2, 0xb7, 0xcd, 0x3b, 0xde, 0x26, 0x77, 0x87, 0x0c, 0x35, 0x1f, 0xb7,
+ 0x46, 0xe9, 0x19, 0x75, 0x04, 0x5a, 0x6e,
+ ],
+ [
+ 0x2b, 0x46, 0xed, 0xca, 0x75, 0x25, 0xc0, 0x8c, 0xce, 0xaa, 0x09, 0x4c, 0xf6,
+ 0xe1, 0x21, 0x7a, 0x5e, 0xca, 0x96, 0x57, 0xf8, 0xf0, 0x7f, 0x2f, 0x36, 0xde,
+ 0xeb, 0xc6, 0x96, 0x83, 0x07, 0x33,
+ ],
+ [
+ 0x26, 0xe0, 0x7b, 0x3e, 0xc4, 0xb7, 0xe9, 0x69, 0xb9, 0x38, 0x53, 0x54, 0x67,
+ 0x78, 0xe5, 0x85, 0x54, 0xaa, 0x15, 0x96, 0xc4, 0xe1, 0xbc, 0xb6, 0x89, 0x27,
+ 0xb6, 0x12, 0xf8, 0x61, 0xe0, 0x25, 0xa0, 0xf0, 0x03, 0x4e, 0xaa, 0xa3, 0xc0,
+ 0xf4, 0xa0, 0x7a, 0x6e, 0x89, 0xb0, 0xff, 0x83, 0xa3,
+ ],
+ [
+ 0x30, 0xe8, 0xf4, 0xc5, 0x66, 0xd5, 0xb8, 0x51, 0x92, 0x2e, 0xb4, 0x88, 0x04,
+ 0xff, 0xb4, 0xf2, 0x2f, 0xf6, 0xc6, 0x67, 0xe0, 0x01, 0x0e, 0xa9, 0x44, 0x6e,
+ 0x7e, 0xe7, 0x75, 0x8d, 0x46, 0xb8, 0x59, 0x50, 0xec, 0x74, 0x3e, 0x70, 0x43,
+ 0x41, 0xb1, 0xa5, 0x2e, 0xfa, 0x66, 0xe9, 0xba, 0x4e, 0xda, 0x01, 0x6d, 0x77,
+ 0x88, 0x53, 0xb8, 0xc5, 0xaa, 0xd1, 0xe0, 0x50, 0xa3, 0xb9, 0x16, 0x87,
+ ]
+ ),
+ test_case!(
+ [
+ 0x3c, 0x02, 0xd2, 0xb6, 0x75, 0x66, 0x8a, 0xb4, 0x94, 0x3a, 0x75, 0xb0, 0x80,
+ 0xda, 0x20, 0x47, 0x47, 0x02, 0xdb, 0xf5, 0xf0, 0xbd, 0x54, 0xc8, 0x54, 0x93,
+ 0xcf, 0x91, 0x29, 0xba, 0x63, 0xde, 0xd2, 0xc9, 0xb3, 0x78, 0x13, 0xae, 0x92,
+ 0xc2, 0xe7, 0xb0, 0xca, 0xac, 0x6a, 0x07, 0xb9, 0xf2, 0x92, 0x2d, 0x4c, 0xef,
+ 0xc7, 0xd3, 0x4b, 0x1a, 0x63, 0x44, 0xe8, 0x35, 0x19, 0xb7, 0x13,
+ ],
+ [
+ 0x83, 0xd4, 0xd8, 0x4b, 0x9c, 0x88, 0xdd, 0xf5, 0xed, 0x07, 0x04, 0x23, 0xc0,
+ 0x4b, 0x44, 0x0d, 0x12, 0x1d, 0x89, 0xd9,
+ ],
+ [
+ 0x0a, 0x45, 0xb7, 0xe1, 0xcb, 0xfd, 0x9f, 0xb7, 0xbb, 0x82, 0xa4, 0x57, 0xf4,
+ 0x44, 0x83, 0x2b, 0x2a, 0x74, 0x81, 0x5e, 0x31, 0x36, 0xe4, 0x2c, 0x53, 0xae,
+ 0xdc, 0x52, 0x65, 0x29, 0x7c, 0x7e,
+ ],
+ [
+ 0x4f, 0xe1, 0x70, 0x48, 0x52, 0xc0, 0x54, 0xda, 0xac, 0x7f, 0xaf, 0x90, 0x9a,
+ 0x1b, 0xb7, 0x33, 0x93, 0xbb, 0xa5, 0x5d, 0xb2, 0x4f, 0xd0, 0x04, 0x13, 0x8d,
+ 0x9f, 0x77, 0xc9, 0xaa, 0xb3, 0x2f, 0xb7, 0xcb, 0x8e, 0x1d, 0xa1, 0xd4, 0xaf,
+ 0x44, 0x70, 0xb3, 0xa2, 0xd9, 0xfd, 0xf6, 0xcd, 0x4a,
+ ],
+ [
+ 0x95, 0x75, 0x49, 0x7a, 0xfc, 0x34, 0x68, 0xde, 0x7f, 0x35, 0x8f, 0x49, 0x30,
+ 0x3a, 0x1b, 0x8e, 0xb4, 0x2e, 0xaa, 0x04, 0xe7, 0x2b, 0xf7, 0x81, 0x56, 0x5a,
+ 0xbf, 0xd9, 0xa8, 0xe0, 0xf7, 0xd1, 0x66, 0x50, 0x9b, 0x05, 0xdb, 0x6c, 0x64,
+ 0xb3, 0xc6, 0xb7, 0x7d, 0x63, 0xfb, 0x4c, 0xb0, 0xeb, 0x44, 0xb3, 0x20, 0x5a,
+ 0x63, 0xf0, 0x52, 0xa1, 0x76, 0x29, 0xa8, 0x69, 0xbd, 0xf3, 0x66, 0xed,
+ ]
+ ),
+ test_case!(
+ [
+ 0x12, 0x1e, 0x67, 0xda, 0x20, 0x99, 0xdb, 0x3d, 0xeb, 0xd0, 0xee, 0xab, 0x37,
+ 0x41, 0x25, 0xbe, 0x63, 0x69, 0x87, 0xe1, 0x19, 0x3a, 0x90, 0xd4, 0xb7, 0x59,
+ 0xe4, 0x6b, 0xc0, 0xc9, 0xe2, 0xa9, 0x54, 0x18, 0xd1, 0x9c, 0xae, 0x4b, 0x56,
+ 0xa0, 0x24, 0xb4, 0x05, 0x20, 0x74, 0xcb, 0x5d, 0x4a, 0x4e, 0x2a, 0x53, 0xf1,
+ 0x8a, 0x33, 0x19, 0xa0, 0x82, 0x6e, 0xfb, 0xaf, 0xda, 0x9a, 0xa2, 0x4f,
+ ],
+ [
+ 0xd5, 0x3d, 0xcb, 0xb6, 0xd2, 0x42, 0x50, 0xd0, 0x23, 0xf1, 0x98, 0xac, 0x78,
+ 0x3f, 0x5e, 0x9b, 0x7f, 0x87, 0x9c, 0x6b,
+ ],
+ [
+ 0xdc, 0xa2, 0x04, 0x22, 0xd0, 0x32, 0x08, 0x2b, 0xc5, 0x22, 0x78, 0xba, 0xfd,
+ 0x6e, 0x81, 0xb8, 0x74, 0x68, 0xe3, 0xa1, 0x12, 0x9e, 0xd4, 0x50, 0x6b, 0xc3,
+ 0x1e, 0xf6, 0x8f, 0xcb, 0x7c, 0xa0,
+ ],
+ [
+ 0xa4, 0xfb, 0x1f, 0xb7, 0xa0, 0xfa, 0xcf, 0xa5, 0x2c, 0x9b, 0x49, 0xc8, 0xd8,
+ 0x0b, 0x3c, 0xa9, 0xca, 0xbc, 0x34, 0x83, 0xae, 0x1f, 0x3c, 0xc7, 0x00, 0x89,
+ 0x67, 0x35, 0x18, 0x9f, 0x06, 0xf8, 0x94, 0xf9, 0x7a, 0x85, 0x28, 0xa6, 0x4e,
+ 0xca, 0xc5, 0x2d, 0xbd, 0xd9, 0x7d, 0x95, 0xa3, 0x8b,
+ ],
+ [
+ 0x0d, 0x3a, 0x84, 0x73, 0xfb, 0xe7, 0x94, 0x0f, 0x91, 0x69, 0xd1, 0x37, 0x4c,
+ 0x43, 0x95, 0xa6, 0x8f, 0xbf, 0xf0, 0xfb, 0x40, 0x75, 0x52, 0x15, 0x7f, 0xef,
+ 0xe8, 0xa6, 0x26, 0x0c, 0x57, 0xe7, 0x3b, 0x37, 0x93, 0xe1, 0x11, 0x07, 0x96,
+ 0xc5, 0x8f, 0x9d, 0x3b, 0x81, 0x99, 0x70, 0xa4, 0x3a, 0x0c, 0x04, 0x94, 0x2b,
+ 0xca, 0xa8, 0xf8, 0x6a, 0x04, 0x6b, 0x52, 0x1c, 0xa6, 0x08, 0xca, 0x2e,
+ ]
+ ),
+ test_case!(
+ [
+ 0x92, 0x83, 0x41, 0xf1, 0x03, 0x26, 0x34, 0xb6, 0xf2, 0x68, 0xb3, 0x55, 0x51,
+ 0x06, 0xb1, 0x62, 0x42, 0xae, 0x66, 0x9c, 0xae, 0xf4, 0x62, 0xcb, 0x97, 0xe5,
+ 0xd8, 0xdc, 0x40, 0x29, 0x00, 0x3d, 0x1c, 0x43, 0xf9, 0xa7, 0x51, 0xd0, 0x75,
+ 0x95, 0x53, 0xb9, 0xc8, 0xe6, 0x87, 0xa8, 0x2f, 0x52, 0xf9, 0xf0, 0x1d, 0xa8,
+ 0x14, 0xbc, 0x99, 0xe1, 0x59, 0x44, 0x7b, 0x85, 0x38, 0x0c, 0xa0, 0x64, 0x20,
+ ],
+ [
+ 0x36, 0x36, 0xbf, 0xeb, 0x6a, 0x32, 0xbc, 0x28, 0xc9, 0xa6, 0x60, 0x0c, 0x9d,
+ 0x7b, 0xab, 0x5e, 0x9b, 0xb3, 0x7b, 0xd5,
+ ],
+ [
+ 0x05, 0x4f, 0xab, 0xe6, 0xec, 0x76, 0xc2, 0xff, 0x2e, 0x8a, 0xdc, 0xd7, 0xc8,
+ 0x49, 0x01, 0x19, 0xef, 0x04, 0xe7, 0x2f, 0x1e, 0xea, 0x55, 0x74, 0x54, 0x27,
+ 0x79, 0xf8, 0xd5, 0x34, 0xba, 0xb8,
+ ],
+ [
+ 0xef, 0x4e, 0x7b, 0xa7, 0x5f, 0xe2, 0x64, 0x04, 0xaa, 0x3e, 0xce, 0x0a, 0xe7,
+ 0xb2, 0x09, 0x84, 0xba, 0x9a, 0x85, 0xb1, 0x9e, 0x3d, 0x05, 0x4a, 0x4a, 0x6d,
+ 0xdc, 0xb8, 0x73, 0xad, 0x31, 0x19, 0x73, 0xa1, 0x36, 0x29, 0x9a, 0x2c, 0x62,
+ 0xb5, 0xef, 0x31, 0xe5, 0x39, 0xd4, 0x27, 0x55, 0x98,
+ ],
+ [
+ 0x6a, 0x7c, 0xcf, 0x12, 0x78, 0x7a, 0xcc, 0xfd, 0xb6, 0xc2, 0x47, 0xe7, 0x68,
+ 0x61, 0x53, 0xf8, 0xb3, 0xe6, 0x3d, 0x97, 0x13, 0x27, 0x49, 0x83, 0x15, 0x18,
+ 0xb8, 0x0d, 0x2b, 0x45, 0xd0, 0xe1, 0xfe, 0xb5, 0xfd, 0xad, 0x6a, 0x5d, 0x4b,
+ 0x4b, 0xc8, 0x49, 0x86, 0x8a, 0xbb, 0x80, 0x20, 0x68, 0xd9, 0x3d, 0xcd, 0xa0,
+ 0x8a, 0x59, 0x97, 0x43, 0x03, 0x1b, 0xbc, 0x04, 0xf2, 0xfb, 0x80, 0x6f,
+ ]
+ ),
+ test_case!(
+ [
+ 0x0b, 0xe1, 0x8e, 0xc9, 0xc7, 0x69, 0x83, 0x97, 0x95, 0x8f, 0x9e, 0x93, 0x90,
+ 0xd8, 0xbe, 0xd1, 0x79, 0xdc, 0x12, 0x9c, 0x8d, 0xd5, 0xf7, 0x6f, 0xf1, 0x96,
+ 0x18, 0xbd, 0x4e, 0x92, 0xe5, 0xfe, 0x15, 0x85, 0xfc, 0xa8, 0x5d, 0x16, 0x3b,
+ 0x48, 0x1f, 0x80, 0x1e, 0x38, 0x7e, 0x3c, 0x00, 0x0a, 0xc2, 0x09, 0xc0, 0xf0,
+ 0x95, 0x51, 0xe0, 0x39, 0x8b, 0x49, 0x9f, 0x8e, 0x0a, 0x3a, 0xf4, 0xc4, 0xda,
+ 0xa5,
+ ],
+ [
+ 0xc6, 0xb0, 0x83, 0x31, 0x92, 0xa7, 0xc3, 0xff, 0x9b, 0xdb, 0xfa, 0xa9, 0x83,
+ 0x2a, 0x0d, 0xd4, 0x9c, 0x70, 0xbe, 0x73,
+ ],
+ [
+ 0xa1, 0xfd, 0x84, 0xbf, 0xb5, 0x9f, 0x2f, 0x2c, 0x20, 0x9b, 0x2d, 0x95, 0x71,
+ 0x10, 0x9c, 0x9f, 0xe9, 0x0a, 0xe3, 0xa6, 0x81, 0x08, 0xf6, 0x74, 0xdb, 0x7f,
+ 0x23, 0x78, 0x5b, 0x2a, 0x46, 0xab,
+ ],
+ [
+ 0xfe, 0x11, 0xa9, 0x95, 0xe0, 0x54, 0x34, 0x6f, 0xc8, 0x13, 0xe3, 0x29, 0xcf,
+ 0x68, 0x56, 0x34, 0x19, 0x1d, 0xe1, 0xa4, 0xda, 0x58, 0x0f, 0xc2, 0x67, 0xf2,
+ 0x89, 0x5f, 0x93, 0x3f, 0x74, 0x1c, 0x4d, 0xe9, 0x03, 0xd8, 0xee, 0xf6, 0x13,
+ 0x0a, 0x8e, 0x93, 0x20, 0x11, 0x53, 0x9f, 0x8e, 0xdb,
+ ],
+ [
+ 0xc4, 0xf6, 0xc2, 0xd4, 0x41, 0x4b, 0xd9, 0xee, 0x97, 0xa3, 0x98, 0x49, 0xd0,
+ 0x1d, 0xbd, 0x8c, 0x0d, 0x39, 0x1b, 0xc9, 0x67, 0x35, 0x4b, 0xae, 0xb4, 0xd6,
+ 0x5e, 0x1c, 0x0b, 0xbc, 0x5a, 0x81, 0x4a, 0x61, 0x3d, 0x4d, 0xcd, 0xe5, 0xf1,
+ 0x7b, 0x87, 0x7a, 0x49, 0xa3, 0x2d, 0x02, 0x5f, 0xfe, 0xf6, 0x8d, 0x51, 0x99,
+ 0x9b, 0x66, 0x13, 0xdb, 0x9a, 0x3f, 0xf9, 0xc8, 0xb7, 0x45, 0x03, 0x0e,
+ ]
+ ),
+ test_case!(
+ [
+ 0xc3, 0x78, 0xc0, 0x93, 0x25, 0x94, 0x37, 0xfa, 0x21, 0x99, 0xb0, 0xbb, 0xa1,
+ 0xe9, 0x8d, 0xcb, 0x76, 0x4a, 0x71, 0x3c, 0xa9, 0x07, 0x6c, 0xe7, 0x20, 0x6c,
+ 0xeb, 0xe7, 0xb9, 0x27, 0x4a, 0x48, 0x55, 0x98, 0x2e, 0xba, 0x27, 0x88, 0x65,
+ 0x30, 0xbf, 0x08, 0xc6, 0x17, 0x26, 0x00, 0x9b, 0x22, 0xa2, 0xf8, 0xfb, 0x2f,
+ 0xdc, 0x1a, 0xf1, 0x05, 0x1e, 0x45, 0x4e, 0x2c, 0xf5, 0xaa, 0x52, 0xb0, 0xda,
+ 0xa4, 0x15,
+ ],
+ [
+ 0x56, 0xc5, 0x36, 0xa2, 0x8f, 0xa3, 0x20, 0x78, 0x4f, 0x3e, 0x4b, 0x14, 0x59,
+ 0x0c, 0x5e, 0x63, 0x52, 0xb9, 0xe6, 0xed,
+ ],
+ [
+ 0x24, 0x2b, 0xb2, 0xb4, 0xa1, 0xd7, 0xd9, 0x83, 0x26, 0xfe, 0x43, 0x50, 0x3d,
+ 0xbe, 0x1d, 0x35, 0x0d, 0x7b, 0xae, 0x34, 0xb8, 0xc9, 0xd9, 0x62, 0x4f, 0x2b,
+ 0xf3, 0x2c, 0x5e, 0x28, 0xa4, 0xc3,
+ ],
+ [
+ 0x83, 0x74, 0xd4, 0x7b, 0x2a, 0x99, 0xde, 0x70, 0xa5, 0x7f, 0x86, 0x11, 0xb5,
+ 0x09, 0x65, 0x54, 0x9e, 0x2b, 0x48, 0x73, 0x9e, 0xa6, 0xe1, 0xb9, 0x2e, 0x67,
+ 0x9d, 0xb9, 0x9f, 0x64, 0x14, 0x0b, 0x72, 0x6d, 0xf7, 0x32, 0x66, 0x7d, 0xac,
+ 0xb1, 0xba, 0x10, 0xd9, 0xf3, 0xd5, 0xfa, 0x9e, 0xb8,
+ ],
+ [
+ 0xab, 0xdd, 0xbd, 0x1b, 0xa7, 0x21, 0x15, 0x3a, 0xe8, 0xc7, 0x76, 0x96, 0x01,
+ 0xf2, 0x0b, 0x4b, 0x4d, 0xef, 0xf3, 0x38, 0x7a, 0x7b, 0xd0, 0x9f, 0xeb, 0x3a,
+ 0x84, 0x59, 0xd8, 0xf2, 0xda, 0xf2, 0xbe, 0xb7, 0x9e, 0x37, 0x34, 0x1d, 0xa9,
+ 0x4d, 0xab, 0x49, 0xda, 0xbb, 0xe4, 0x84, 0x29, 0x71, 0xda, 0x1b, 0x38, 0x54,
+ 0x76, 0x3f, 0x34, 0xd5, 0xf3, 0xe9, 0xcc, 0xb3, 0xd2, 0x93, 0x2c, 0x59,
+ ]
+ ),
+ test_case!(
+ [
+ 0x9b, 0xc2, 0x33, 0xd0, 0x2e, 0x1f, 0xd0, 0xe4, 0x9d, 0x54, 0x97, 0x15, 0x1a,
+ 0x7e, 0xd7, 0xb3, 0x90, 0x8a, 0x99, 0x4e, 0x81, 0x66, 0xe4, 0xcd, 0x42, 0x63,
+ 0x6b, 0x52, 0x27, 0xb5, 0x6c, 0x9b, 0x2a, 0x75, 0xd8, 0x2d, 0x23, 0xbd, 0x00,
+ 0xff, 0x1e, 0x89, 0x9e, 0xc9, 0x56, 0xc4, 0xa4, 0x16, 0xa4, 0x60, 0xd9, 0x84,
+ 0xc9, 0xae, 0xb3, 0x2c, 0xb4, 0xd8, 0x00, 0x53, 0x5f, 0x25, 0x45, 0x74, 0x0b,
+ 0x2c, 0x7f, 0x94,
+ ],
+ [
+ 0x42, 0xd5, 0xe6, 0x08, 0xe5, 0xa1, 0x03, 0x8c, 0x89, 0x3b, 0x4f, 0x03, 0x14,
+ 0x7f, 0x2a, 0x03, 0xa0, 0xf2, 0x9b, 0x4f,
+ ],
+ [
+ 0xb9, 0x74, 0x1b, 0x8f, 0x66, 0xee, 0xe2, 0x74, 0xc5, 0x71, 0xe1, 0xfe, 0xac,
+ 0x2f, 0x8c, 0xb7, 0xb2, 0x52, 0xde, 0xf2, 0x08, 0x96, 0x00, 0xcd, 0x59, 0xec,
+ 0x67, 0x29, 0x1f, 0xd1, 0x99, 0xef,
+ ],
+ [
+ 0xf3, 0x02, 0x5e, 0x4c, 0x64, 0x23, 0xab, 0xaa, 0x0e, 0xa8, 0xbc, 0xa4, 0x3f,
+ 0x48, 0x05, 0x5c, 0xca, 0x5e, 0xe2, 0xb5, 0x82, 0x68, 0x2c, 0xf4, 0xae, 0xd2,
+ 0xaf, 0xe3, 0x73, 0xbc, 0xe7, 0xb7, 0x7a, 0x07, 0x60, 0xc0, 0x12, 0x39, 0x49,
+ 0x61, 0x63, 0x4f, 0x6d, 0xc0, 0x4a, 0x3e, 0xf2, 0xf8,
+ ],
+ [
+ 0xc5, 0x74, 0xc4, 0x4f, 0x2e, 0xf8, 0xd8, 0x37, 0x70, 0x9a, 0x10, 0x31, 0x8e,
+ 0xc6, 0x0e, 0xb0, 0xa5, 0x97, 0xbf, 0xd6, 0xa1, 0xe8, 0xb1, 0x57, 0xbb, 0x81,
+ 0x98, 0x0d, 0x56, 0x00, 0x29, 0xd8, 0xc1, 0x3a, 0x21, 0xa4, 0xbd, 0x15, 0x12,
+ 0xf8, 0x4a, 0x94, 0x8c, 0x38, 0x17, 0x15, 0x54, 0xbe, 0x4b, 0x98, 0x3a, 0x5b,
+ 0x1d, 0xc0, 0x52, 0x76, 0xae, 0x68, 0x14, 0xd5, 0xfc, 0x2d, 0xd0, 0x10,
+ ]
+ ),
+ test_case!(
+ [
+ 0x47, 0xd5, 0x60, 0x14, 0x8b, 0xe6, 0x2e, 0x40, 0x14, 0xf8, 0xa1, 0x37, 0x46,
+ 0xa6, 0x79, 0xde, 0x4c, 0x60, 0xdd, 0xdd, 0x17, 0xc5, 0x6d, 0x29, 0x8c, 0xf6,
+ 0x9b, 0x63, 0xf3, 0xee, 0x02, 0xce, 0xe0, 0x5a, 0x5d, 0xb5, 0x94, 0x42, 0xa2,
+ 0x3c, 0x12, 0x19, 0xa4, 0xfa, 0x4d, 0xe3, 0x2d, 0x75, 0xd8, 0x2b, 0x9e, 0x2e,
+ 0x8e, 0x91, 0xca, 0xbb, 0x42, 0x14, 0xd7, 0x84, 0x9e, 0x4a, 0xfe, 0x67, 0xa2,
+ 0xf1, 0x98, 0xd0, 0x2c,
+ ],
+ [
+ 0x52, 0xe0, 0x5e, 0x83, 0x26, 0xb5, 0x87, 0x8f, 0xb0, 0x86, 0x1e, 0x7f, 0x34,
+ 0x42, 0x11, 0x39, 0x72, 0x4a, 0x7f, 0x03,
+ ],
+ [
+ 0x09, 0x0d, 0x0d, 0x4d, 0x3c, 0x58, 0xe4, 0x97, 0x11, 0x22, 0x17, 0x4a, 0xf8,
+ 0x57, 0xaf, 0x6c, 0xb0, 0x5f, 0xff, 0x63, 0x9c, 0xf3, 0xf1, 0xd1, 0x8b, 0x83,
+ 0xb1, 0x77, 0x84, 0xe9, 0x68, 0x86,
+ ],
+ [
+ 0x94, 0x59, 0xe5, 0x9d, 0x7a, 0xb8, 0x45, 0x18, 0xe1, 0x76, 0x72, 0x71, 0x06,
+ 0xf9, 0x82, 0x1b, 0xd5, 0xcf, 0x27, 0x0a, 0x8b, 0x39, 0x3e, 0xac, 0x70, 0xd7,
+ 0xb3, 0xcf, 0x2a, 0xc9, 0x63, 0x0a, 0x67, 0x8f, 0xc1, 0x10, 0x80, 0x7f, 0x98,
+ 0x01, 0x4d, 0xfe, 0xe9, 0x16, 0x24, 0xbb, 0x7a, 0xb8,
+ ],
+ [
+ 0xab, 0xfd, 0xc8, 0xf4, 0x57, 0xfb, 0xd2, 0x87, 0xe8, 0x59, 0xec, 0x9a, 0x30,
+ 0x46, 0x87, 0x17, 0x86, 0x19, 0xd7, 0x3b, 0xf8, 0x34, 0x15, 0x9a, 0x92, 0x92,
+ 0x66, 0x5f, 0x2e, 0x56, 0x4c, 0xbd, 0xf0, 0x9e, 0x14, 0x78, 0x55, 0x93, 0x0c,
+ 0x5a, 0x56, 0x81, 0xc7, 0x27, 0x60, 0x05, 0x60, 0x59, 0x76, 0x9f, 0x50, 0x54,
+ 0xfb, 0x3a, 0x38, 0xaf, 0xf6, 0x0b, 0x55, 0xc5, 0xa9, 0x19, 0x5d, 0x13,
+ ]
+ ),
+ test_case!(
+ [
+ 0xf4, 0xc9, 0x85, 0x8d, 0x46, 0x0f, 0x3d, 0x63, 0x9a, 0x9c, 0x31, 0x86, 0x64,
+ 0x05, 0x2c, 0xce, 0xb4, 0xb3, 0xb2, 0x5c, 0x95, 0xa3, 0xcf, 0xaf, 0x88, 0xa6,
+ 0xb0, 0x4c, 0x2e, 0xed, 0xca, 0xb1, 0xa2, 0xb6, 0x03, 0x85, 0xc2, 0x68, 0xa8,
+ 0xc8, 0xb2, 0x02, 0x92, 0x07, 0xf4, 0xa1, 0x6b, 0x77, 0x92, 0xdd, 0x54, 0x30,
+ 0x9f, 0x53, 0xcb, 0x55, 0x15, 0xb5, 0x1f, 0x7f, 0x45, 0xe1, 0x6c, 0xb5, 0xf9,
+ 0xed, 0xc1, 0x64, 0x52, 0xe4,
+ ],
+ [
+ 0xb4, 0x3a, 0xe2, 0xe2, 0x1f, 0x71, 0x99, 0x96, 0xe1, 0x04, 0xaf, 0x74, 0x59,
+ 0x36, 0xdb, 0xe7, 0x65, 0x02, 0x5a, 0xc7,
+ ],
+ [
+ 0x4a, 0x8f, 0xfb, 0x41, 0x16, 0xc9, 0x2c, 0x87, 0x5c, 0x95, 0x5e, 0x03, 0x25,
+ 0x67, 0x94, 0xe3, 0x78, 0x8f, 0x57, 0x8e, 0x48, 0x0b, 0xfc, 0xe7, 0x4f, 0x07,
+ 0x57, 0x9b, 0xcc, 0x6d, 0x08, 0x45,
+ ],
+ [
+ 0x08, 0xbb, 0x72, 0xd5, 0xa6, 0xdb, 0xe6, 0x6a, 0x1b, 0x20, 0x12, 0x43, 0x2c,
+ 0x5f, 0xee, 0xa3, 0xcc, 0xff, 0xbb, 0xe2, 0xa9, 0x90, 0x52, 0x5a, 0x16, 0x82,
+ 0x68, 0x29, 0xab, 0x64, 0xfb, 0x3c, 0x85, 0x08, 0x91, 0x9e, 0x15, 0x52, 0xf4,
+ 0xd5, 0xe8, 0x09, 0x77, 0x30, 0x1d, 0xc9, 0x6a, 0xd7,
+ ],
+ [
+ 0x94, 0x27, 0x6e, 0x87, 0x16, 0x21, 0x09, 0xf2, 0x31, 0xc9, 0xc9, 0x5f, 0xff,
+ 0x2d, 0x34, 0x9c, 0xce, 0x7f, 0x62, 0x98, 0xff, 0xe0, 0x00, 0x61, 0x9f, 0x09,
+ 0x21, 0x4c, 0xe5, 0xd9, 0xad, 0xb5, 0x61, 0x8a, 0xf1, 0x9f, 0xd2, 0x70, 0x0f,
+ 0x51, 0xa4, 0x1c, 0x72, 0x94, 0x03, 0x6b, 0x39, 0x58, 0xb1, 0x50, 0x0c, 0x29,
+ 0x37, 0x06, 0x1c, 0x2c, 0xc6, 0xb9, 0x67, 0x46, 0xcc, 0xec, 0xc5, 0x0e,
+ ]
+ ),
+ test_case!(
+ [
+ 0x86, 0x53, 0x1b, 0x41, 0x37, 0xeb, 0x3a, 0x82, 0xd7, 0xb2, 0xca, 0x24, 0xd9,
+ 0xfa, 0x81, 0x48, 0xf3, 0x97, 0x20, 0xc4, 0x11, 0x08, 0x47, 0x02, 0x2c, 0x91,
+ 0x20, 0x20, 0xd6, 0x38, 0xa9, 0x69, 0x2d, 0x0f, 0x93, 0x4b, 0x1d, 0x66, 0xd6,
+ 0x59, 0xd1, 0x25, 0x9a, 0x87, 0x90, 0xba, 0x56, 0x13, 0xed, 0x7a, 0xbc, 0x5a,
+ 0x94, 0xf8, 0x5f, 0xfd, 0xdb, 0x01, 0x32, 0xf1, 0xe0, 0x04, 0xf2, 0xc4, 0x52,
+ 0x73, 0x6c, 0x3e, 0xe4, 0x70, 0xb3,
+ ],
+ [
+ 0x6c, 0x50, 0x2f, 0x67, 0x62, 0x17, 0x30, 0x7c, 0xed, 0x42, 0x7a, 0xb7, 0xf4,
+ 0x63, 0xd0, 0xd9, 0xc9, 0xe3, 0xd6, 0x9a,
+ ],
+ [
+ 0xc3, 0xc4, 0x00, 0x6e, 0x51, 0xbb, 0xbc, 0x55, 0xa3, 0xa8, 0xd2, 0x17, 0xeb,
+ 0x19, 0xd8, 0x29, 0x39, 0x1d, 0x3c, 0x4d, 0x30, 0xdc, 0x0d, 0xe8, 0x32, 0xbb,
+ 0x66, 0x59, 0x29, 0xe9, 0x7c, 0xd9,
+ ],
+ [
+ 0x00, 0x6c, 0xb9, 0xe6, 0x3e, 0x95, 0x77, 0x7f, 0x97, 0xb6, 0x07, 0x97, 0x4c,
+ 0x3c, 0x94, 0x83, 0x7d, 0x46, 0xc0, 0xff, 0xdf, 0x22, 0xa3, 0xc7, 0x9a, 0x96,
+ 0x5f, 0xc0, 0x09, 0x31, 0x2f, 0x57, 0xe6, 0xb1, 0x7d, 0x5b, 0xb5, 0xdd, 0x9b,
+ 0x16, 0xd4, 0xbe, 0xeb, 0x87, 0xa8, 0x88, 0xda, 0x5f,
+ ],
+ [
+ 0x62, 0x4a, 0x92, 0x2d, 0x96, 0xdb, 0xaa, 0x58, 0x4c, 0x47, 0x48, 0xbb, 0x8b,
+ 0x6a, 0xa6, 0xff, 0xe0, 0xf1, 0xc9, 0xa4, 0xd0, 0xea, 0x4a, 0xcd, 0xa8, 0x94,
+ 0x9a, 0x35, 0x81, 0x72, 0xfd, 0xe8, 0xcb, 0xec, 0x0b, 0x42, 0x9b, 0x10, 0x4b,
+ 0x08, 0xb9, 0x3b, 0x24, 0x4a, 0x4d, 0xc6, 0xcb, 0xb9, 0xaa, 0xfd, 0x3c, 0x89,
+ 0xe4, 0x87, 0xa5, 0xff, 0x74, 0x85, 0xa9, 0x2e, 0x23, 0x3c, 0x27, 0xe1,
+ ]
+ ),
+ test_case!(
+ [
+ 0xfb, 0x68, 0x87, 0x9d, 0x96, 0x8c, 0x7e, 0xa5, 0xfd, 0x03, 0x4e, 0x21, 0x0b,
+ 0x75, 0x01, 0xad, 0x24, 0x34, 0x05, 0xda, 0x7f, 0x7a, 0x6c, 0x21, 0x69, 0xb0,
+ 0x93, 0x93, 0xb8, 0x06, 0x09, 0xd1, 0x51, 0x4d, 0x4a, 0x69, 0xfc, 0x38, 0xa0,
+ 0x40, 0x8c, 0xe3, 0xd7, 0xd0, 0x2b, 0xb3, 0x65, 0xc3, 0x16, 0x6d, 0xe7, 0xc0,
+ 0xcc, 0x44, 0x8c, 0xe9, 0x0f, 0x62, 0xe9, 0x7e, 0xef, 0xe5, 0x5d, 0x57, 0x7b,
+ 0x92, 0xdb, 0xcd, 0xef, 0xd0, 0xde, 0xda,
+ ],
+ [
+ 0x62, 0x5d, 0x51, 0x84, 0xbe, 0x35, 0x83, 0x1f, 0x78, 0xa2, 0x56, 0xf0, 0x6a,
+ 0xbb, 0x40, 0x1c, 0xb9, 0xcd, 0x74, 0x15,
+ ],
+ [
+ 0xe6, 0x9b, 0xc5, 0xbc, 0x32, 0x0a, 0xac, 0x84, 0x68, 0xce, 0xdc, 0x59, 0x56,
+ 0x79, 0x13, 0x0c, 0x14, 0x3b, 0x8e, 0xa3, 0x53, 0x40, 0x16, 0x9d, 0xc0, 0x4c,
+ 0x86, 0xfb, 0x4d, 0x73, 0xd9, 0xfa,
+ ],
+ [
+ 0x39, 0xd1, 0x81, 0xfa, 0x34, 0x4e, 0xed, 0x3b, 0x55, 0xc5, 0x3e, 0xc4, 0xd5,
+ 0x3a, 0x54, 0xf6, 0xa4, 0xad, 0x6c, 0xe5, 0x82, 0xf6, 0x5b, 0x53, 0xa2, 0x1d,
+ 0xa5, 0x2a, 0x18, 0xfb, 0x3d, 0x01, 0x85, 0x8d, 0x54, 0x0b, 0xb1, 0xd8, 0x29,
+ 0x98, 0x6a, 0x12, 0xb8, 0x60, 0x6b, 0x56, 0x71, 0xf2,
+ ],
+ [
+ 0x55, 0xc8, 0xdb, 0x0a, 0x39, 0x10, 0x2c, 0x4f, 0x98, 0xac, 0x8a, 0x06, 0x41,
+ 0xaa, 0x63, 0x3b, 0xd4, 0x21, 0x74, 0x7a, 0xe8, 0xb9, 0x5a, 0x9f, 0xd4, 0x91,
+ 0xcd, 0x49, 0x5a, 0x29, 0x7a, 0x8c, 0x98, 0xd1, 0xda, 0x1c, 0xb2, 0x50, 0xc4,
+ 0x26, 0xf6, 0x40, 0x21, 0x6c, 0x15, 0x11, 0xee, 0x82, 0x1a, 0xc2, 0x6e, 0xd9,
+ 0x69, 0x1c, 0xd2, 0x0e, 0x18, 0xa5, 0x6a, 0xaa, 0xd5, 0x1a, 0xa3, 0x76,
+ ]
+ ),
+ test_case!(
+ [
+ 0xc5, 0xba, 0x96, 0x79, 0xdd, 0x18, 0xe9, 0xb8, 0xcb, 0xd3, 0x8a, 0x60, 0x89,
+ 0xd6, 0xec, 0x41, 0x2f, 0x8c, 0x11, 0xc0, 0x17, 0xab, 0x9d, 0x3c, 0xa6, 0x1f,
+ 0x62, 0xe8, 0x0b, 0x4b, 0xdf, 0xca, 0xe5, 0x62, 0x7a, 0x61, 0x56, 0x45, 0xc1,
+ 0xc0, 0x47, 0x34, 0x24, 0x54, 0x0f, 0xa1, 0xe6, 0xfc, 0x2c, 0x45, 0xac, 0xb1,
+ 0xe6, 0xde, 0xf1, 0x25, 0x84, 0x9e, 0xec, 0xea, 0xcd, 0x1e, 0x5f, 0xce, 0x06,
+ 0xed, 0xe9, 0x74, 0x65, 0x40, 0x45, 0xaf, 0x5a,
+ ],
+ [
+ 0x7b, 0xa7, 0x92, 0xbe, 0x42, 0xb6, 0x4a, 0x49, 0xa6, 0xfd, 0x45, 0xfd, 0xf1,
+ 0x39, 0x43, 0x99, 0xed, 0x51, 0x45, 0x8d,
+ ],
+ [
+ 0xae, 0x5e, 0xa0, 0xbd, 0x47, 0xd7, 0xd4, 0x55, 0xd2, 0xbe, 0xd1, 0x9b, 0x07,
+ 0x41, 0xaa, 0x48, 0x84, 0x1c, 0x25, 0x77, 0x5a, 0x2a, 0xdf, 0x02, 0xc6, 0x78,
+ 0xf8, 0xe3, 0x58, 0xfe, 0x75, 0xbb,
+ ],
+ [
+ 0x38, 0x42, 0xfa, 0xb6, 0x98, 0x8f, 0xa4, 0x75, 0x84, 0xd8, 0xb4, 0x31, 0x04,
+ 0x6b, 0x8c, 0x2f, 0xfe, 0x90, 0x32, 0xf6, 0xa2, 0x03, 0x1c, 0xce, 0x0e, 0x0d,
+ 0x23, 0xd1, 0x1e, 0xc4, 0xa9, 0x07, 0x68, 0x30, 0x9b, 0x06, 0x2b, 0x0f, 0xd3,
+ 0xb7, 0x7f, 0x84, 0xa2, 0x3b, 0x3e, 0x6e, 0xa8, 0x0b,
+ ],
+ [
+ 0xf1, 0x3e, 0x07, 0xb9, 0x52, 0x68, 0xc9, 0xa5, 0x22, 0xa6, 0x75, 0xac, 0x0c,
+ 0x36, 0x97, 0xf3, 0x1c, 0x48, 0xab, 0x11, 0x73, 0xb6, 0x6f, 0x2e, 0x4e, 0x56,
+ 0xc4, 0x00, 0x24, 0x82, 0x51, 0xa7, 0xd1, 0x64, 0x57, 0x8d, 0x25, 0x2e, 0xf8,
+ 0x6c, 0x57, 0x49, 0xbe, 0xb9, 0x8f, 0x49, 0xb1, 0x19, 0x2c, 0xa1, 0xda, 0x96,
+ 0xe5, 0x42, 0x2f, 0x8e, 0x9a, 0xa6, 0xfe, 0xa3, 0xb5, 0xeb, 0x46, 0x48,
+ ]
+ ),
+ test_case!(
+ [
+ 0xef, 0xd4, 0x39, 0x2e, 0x58, 0x6d, 0x6b, 0x4d, 0x00, 0xff, 0xe3, 0x18, 0xbd,
+ 0x17, 0xbf, 0x2d, 0x76, 0x30, 0xa0, 0xd1, 0xa1, 0xdf, 0xb6, 0x19, 0xf5, 0xc6,
+ 0x16, 0xfb, 0x3c, 0x73, 0xc2, 0x1f, 0xd6, 0x81, 0x4f, 0x52, 0x6a, 0xc1, 0xbc,
+ 0x0f, 0xe1, 0x25, 0xf0, 0x95, 0x4a, 0xc1, 0x3a, 0x55, 0xa7, 0x7c, 0xa1, 0x35,
+ 0xe7, 0x9a, 0xca, 0xc8, 0xa5, 0x83, 0x2a, 0x14, 0x5d, 0x5d, 0x87, 0x70, 0x6f,
+ 0x94, 0x15, 0x3b, 0xe9, 0x21, 0x31, 0x5e, 0x35, 0xde,
+ ],
+ [
+ 0xef, 0x61, 0x8f, 0x1e, 0x5e, 0x63, 0xe4, 0x5d, 0xb8, 0x8d, 0xb3, 0xfd, 0x04,
+ 0x39, 0x98, 0xa6, 0xd1, 0xdb, 0x90, 0x2c,
+ ],
+ [
+ 0x7a, 0xdf, 0x93, 0x5e, 0xc2, 0x6c, 0x0e, 0xf2, 0x81, 0x35, 0xa4, 0xbe, 0xc6,
+ 0x66, 0xb1, 0xad, 0x18, 0xc3, 0x2f, 0x7b, 0x7e, 0xd1, 0x77, 0x1b, 0x79, 0xe2,
+ 0x80, 0xe3, 0x6f, 0x11, 0x47, 0x9e,
+ ],
+ [
+ 0xa5, 0xc4, 0x16, 0x17, 0x33, 0x73, 0x61, 0x8e, 0xcf, 0x7a, 0x81, 0x07, 0x5b,
+ 0xeb, 0x22, 0xce, 0xb2, 0xaa, 0xe9, 0xc6, 0x45, 0x82, 0x6d, 0x8b, 0xb7, 0x15,
+ 0x0f, 0x9d, 0x7b, 0x1a, 0xb4, 0xd8, 0x84, 0xc9, 0xe7, 0x99, 0xa7, 0xf5, 0xa8,
+ 0xb2, 0x87, 0x52, 0xd7, 0xe8, 0x17, 0xf9, 0x4f, 0xb7,
+ ],
+ [
+ 0xdb, 0x79, 0x51, 0xba, 0x4c, 0x6b, 0x10, 0xac, 0xb1, 0xda, 0xd9, 0x76, 0x10,
+ 0xad, 0x51, 0xf3, 0x06, 0x52, 0x2e, 0x1d, 0x6f, 0x81, 0x8f, 0x23, 0xb3, 0xee,
+ 0x01, 0xa2, 0xab, 0x37, 0x59, 0xa4, 0x57, 0x5d, 0xb6, 0x8c, 0x7a, 0x91, 0x01,
+ 0xc1, 0xcf, 0xcd, 0x10, 0xbb, 0x99, 0xc0, 0xba, 0xd7, 0x8b, 0x78, 0xbd, 0x78,
+ 0xa5, 0xfd, 0xd2, 0xaa, 0x1e, 0xb7, 0xf5, 0xb7, 0x53, 0xe0, 0x1e, 0x64,
+ ]
+ ),
+ test_case!(
+ [
+ 0x29, 0xf6, 0xd8, 0xac, 0x17, 0xc7, 0xb3, 0x48, 0xbc, 0x8d, 0x58, 0x4c, 0x4b,
+ 0x75, 0x68, 0x4a, 0x21, 0xf6, 0x37, 0x7f, 0x3e, 0xc7, 0x66, 0xc1, 0x6d, 0xb9,
+ 0x6b, 0x3a, 0x23, 0x27, 0xef, 0x37, 0x43, 0x66, 0x35, 0xe1, 0x6c, 0x34, 0x19,
+ 0xea, 0xfe, 0x58, 0x36, 0x80, 0x71, 0xa5, 0x5e, 0x73, 0xb6, 0x09, 0x43, 0xe8,
+ 0x4a, 0xf5, 0x27, 0x8c, 0x5d, 0xab, 0xb3, 0x97, 0x53, 0xae, 0xb0, 0xee, 0xbf,
+ 0x3b, 0x52, 0x4b, 0x73, 0x20, 0x21, 0xd5, 0x31, 0x2a, 0x7d,
+ ],
+ [
+ 0x28, 0x76, 0xbc, 0xa4, 0x0f, 0x29, 0xdc, 0x6a, 0x64, 0xc3, 0xb2, 0x03, 0xbf,
+ 0xca, 0xfd, 0x95, 0x34, 0x27, 0x04, 0xac,
+ ],
+ [
+ 0xd5, 0x3e, 0x89, 0x88, 0xac, 0x91, 0x97, 0x19, 0xd5, 0x1f, 0xe4, 0xd5, 0xaf,
+ 0x42, 0xe9, 0x42, 0x71, 0xde, 0x7c, 0x6b, 0x0b, 0x3d, 0x48, 0xef, 0x84, 0xad,
+ 0x70, 0xab, 0x6e, 0x47, 0xf0, 0x90,
+ ],
+ [
+ 0x67, 0xfb, 0x2f, 0x7e, 0x1a, 0x0a, 0xe1, 0x07, 0xf6, 0x70, 0x00, 0xb1, 0x37,
+ 0xcb, 0x57, 0x5e, 0xaa, 0x1f, 0x6a, 0xd6, 0x66, 0xff, 0xfa, 0xbe, 0xf0, 0x63,
+ 0x06, 0x34, 0xa2, 0xec, 0x81, 0x1b, 0xf0, 0x92, 0xdc, 0x66, 0x02, 0x3d, 0x57,
+ 0x8a, 0xd8, 0x23, 0xd3, 0x1c, 0x66, 0x83, 0x3d, 0x67,
+ ],
+ [
+ 0x25, 0x32, 0x25, 0xab, 0x19, 0xb5, 0x05, 0x13, 0xdb, 0x41, 0x0f, 0x5b, 0xb9,
+ 0x18, 0x91, 0x3d, 0xfc, 0x49, 0x29, 0x9c, 0xe2, 0x6c, 0xfd, 0xc2, 0xe7, 0x15,
+ 0xb7, 0x08, 0x27, 0x20, 0x8f, 0x31, 0xa9, 0x6b, 0x07, 0x61, 0xb6, 0xe3, 0x9b,
+ 0xcc, 0x22, 0x09, 0x04, 0xc8, 0x0f, 0xae, 0xac, 0x7f, 0xe1, 0x99, 0x3d, 0x00,
+ 0x2b, 0xfc, 0x64, 0x9e, 0x6a, 0x43, 0x72, 0x3f, 0x5c, 0x34, 0xa8, 0x18,
+ ]
+ ),
+ test_case!(
+ [
+ 0xba, 0x34, 0xb3, 0x4e, 0xf7, 0x57, 0x8c, 0x9a, 0xe9, 0xd3, 0xc6, 0xd4, 0x19,
+ 0x0c, 0xd2, 0xd1, 0x87, 0x77, 0xf1, 0x2c, 0xd3, 0x40, 0x14, 0x9e, 0x6b, 0xa0,
+ 0x5b, 0xf0, 0x83, 0x8a, 0xc3, 0x29, 0x4d, 0x3f, 0x01, 0xba, 0x62, 0x8c, 0xc6,
+ 0x08, 0xae, 0x57, 0x35, 0x66, 0xac, 0xa9, 0x00, 0xda, 0x14, 0xa5, 0xdb, 0xba,
+ 0x2a, 0x3e, 0x85, 0x63, 0xae, 0xad, 0x1d, 0x70, 0xa5, 0x0d, 0x94, 0xe2, 0xbd,
+ 0x72, 0x79, 0xc0, 0x56, 0x71, 0x53, 0x49, 0x4d, 0x20, 0x69, 0x0c,
+ ],
+ [
+ 0x42, 0x53, 0x8f, 0x1e, 0x36, 0xea, 0xd2, 0x86, 0xb6, 0x0f, 0x25, 0x12, 0x7a,
+ 0x37, 0xbb, 0x52, 0x8a, 0x33, 0x30, 0xb8,
+ ],
+ [
+ 0x6f, 0xb9, 0xbe, 0x1d, 0xf1, 0x87, 0x93, 0x35, 0x31, 0xd3, 0xe3, 0x3e, 0x31,
+ 0x8b, 0x92, 0xfd, 0x73, 0x27, 0xe5, 0xfb, 0x08, 0xf3, 0x23, 0xb6, 0xe8, 0xa4,
+ 0xe9, 0x7b, 0x23, 0xfb, 0x1c, 0xf6,
+ ],
+ [
+ 0x20, 0x82, 0x98, 0x77, 0xe9, 0x83, 0x62, 0xb8, 0x10, 0xe6, 0x55, 0x64, 0x54,
+ 0x94, 0xf4, 0x07, 0x30, 0xab, 0x57, 0x53, 0x62, 0x0f, 0x86, 0x3d, 0x49, 0x53,
+ 0x2b, 0x85, 0xad, 0xc1, 0xab, 0x9b, 0xb7, 0x60, 0x43, 0x55, 0xe4, 0xae, 0x01,
+ 0x37, 0xf6, 0xe3, 0x9d, 0x9a, 0x4d, 0xe4, 0x4b, 0x75,
+ ],
+ [
+ 0x94, 0x39, 0x6c, 0xdc, 0xcc, 0xca, 0x61, 0x8a, 0x94, 0x57, 0x4c, 0x8d, 0x81,
+ 0x66, 0x1c, 0xf8, 0x89, 0xd3, 0x3c, 0x1d, 0x60, 0x4e, 0xae, 0x35, 0xf8, 0x26,
+ 0xc4, 0xc5, 0xce, 0xe9, 0xe2, 0xc0, 0xf3, 0x86, 0xba, 0x68, 0xe1, 0xc7, 0x6d,
+ 0xee, 0xba, 0xc0, 0x74, 0x67, 0x73, 0x65, 0x8d, 0xc2, 0x73, 0xf0, 0x9b, 0x39,
+ 0xb6, 0x34, 0x56, 0x00, 0xde, 0xd7, 0x39, 0xda, 0x4e, 0x8c, 0xe3, 0xee,
+ ]
+ ),
+ test_case!(
+ [
+ 0xe7, 0xfa, 0x43, 0x5f, 0x27, 0xdb, 0x37, 0x40, 0x2d, 0x97, 0x0e, 0x17, 0x46,
+ 0x45, 0xb1, 0x46, 0x5f, 0x6c, 0xf7, 0x88, 0x6c, 0xd8, 0x18, 0xae, 0xd5, 0x6b,
+ 0x4f, 0x40, 0xdf, 0x28, 0x2b, 0x3e, 0x65, 0x56, 0x34, 0x0a, 0xe3, 0x81, 0x3b,
+ 0x83, 0xbc, 0x9a, 0x95, 0xea, 0x2e, 0xc6, 0x48, 0x39, 0x9a, 0x9a, 0xa6, 0x87,
+ 0x59, 0xa1, 0x29, 0xe0, 0xc0, 0xcb, 0x3e, 0x45, 0x72, 0xfc, 0x1e, 0x7d, 0x5e,
+ 0x72, 0x2d, 0xc2, 0x01, 0xa0, 0xf3, 0xc1, 0xc4, 0x1c, 0x68, 0x16, 0xf4,
+ ],
+ [
+ 0xe6, 0xf7, 0xa6, 0x70, 0x37, 0xdd, 0x0a, 0x54, 0xc3, 0x5c, 0xd6, 0x28, 0x1f,
+ 0x8c, 0x11, 0x73, 0x38, 0x71, 0xbc, 0x42,
+ ],
+ [
+ 0x37, 0x64, 0xbe, 0xc7, 0x1e, 0xb8, 0xfd, 0xfb, 0x5a, 0xe8, 0xb4, 0xd7, 0x28,
+ 0xc5, 0x11, 0x54, 0x85, 0xd5, 0xd1, 0xb2, 0x9f, 0x50, 0x13, 0x35, 0x7c, 0x12,
+ 0x87, 0x3f, 0xdc, 0xef, 0xad, 0x7f,
+ ],
+ [
+ 0x35, 0x5e, 0xca, 0xc7, 0x52, 0xb3, 0x3b, 0xf5, 0xfb, 0x48, 0x56, 0x15, 0xb3,
+ 0x92, 0x1a, 0x0b, 0x85, 0x90, 0xac, 0x84, 0x56, 0xf2, 0x6a, 0x7d, 0x2f, 0x7b,
+ 0x03, 0x2a, 0x2a, 0xc5, 0x35, 0x76, 0x25, 0x5b, 0x4d, 0x9e, 0xcf, 0xbf, 0x5f,
+ 0x9a, 0xa1, 0x86, 0x5f, 0xc4, 0xd7, 0xed, 0x13, 0xe6,
+ ],
+ [
+ 0x02, 0xf2, 0x7e, 0x98, 0x3e, 0x60, 0xf6, 0x2b, 0x40, 0x8d, 0x94, 0x28, 0xd8,
+ 0xed, 0x6e, 0x2b, 0x6c, 0x55, 0x89, 0x48, 0x54, 0x07, 0xc7, 0x8c, 0xcb, 0x3c,
+ 0x71, 0x08, 0xd2, 0x06, 0x0b, 0xf2, 0x4e, 0x5c, 0xe7, 0x26, 0x6d, 0xd4, 0x7a,
+ 0xde, 0xd0, 0xd5, 0xab, 0xdf, 0xe9, 0xf2, 0x78, 0xbb, 0x35, 0x88, 0x06, 0xdd,
+ 0x34, 0x5a, 0x05, 0x12, 0x33, 0x9b, 0x69, 0xda, 0xcf, 0x28, 0x46, 0x7c,
+ ]
+ ),
+ test_case!(
+ [
+ 0x58, 0xab, 0xd6, 0x8c, 0x2c, 0xa5, 0x97, 0x40, 0x6c, 0xde, 0xdb, 0xef, 0xa2,
+ 0x3c, 0xbc, 0xd7, 0xd8, 0x66, 0xaf, 0x36, 0x06, 0x8c, 0x80, 0x3f, 0xbd, 0xa6,
+ 0xb2, 0xcb, 0xb2, 0x4b, 0xa0, 0x47, 0xec, 0xcf, 0xc2, 0xe7, 0x37, 0xbe, 0xa9,
+ 0x6c, 0x8f, 0xcd, 0x92, 0xe4, 0x3f, 0xd3, 0x92, 0x70, 0x25, 0xd9, 0x03, 0xbf,
+ 0xb4, 0x27, 0xf7, 0xc5, 0x34, 0x0e, 0x69, 0xae, 0x9a, 0x2e, 0x0a, 0x77, 0xf7,
+ 0x3e, 0xda, 0x5e, 0x28, 0x96, 0xb3, 0xa0, 0xca, 0x43, 0xd6, 0xd6, 0x22, 0x17,
+ ],
+ [
+ 0xa0, 0xff, 0x83, 0x7d, 0xbb, 0xdc, 0xc5, 0x69, 0x0a, 0xf0, 0x82, 0x92, 0x8e,
+ 0x72, 0xec, 0x37, 0xb7, 0x46, 0x22, 0xb4,
+ ],
+ [
+ 0xf9, 0x4d, 0xac, 0xdd, 0x0b, 0x44, 0x59, 0x1a, 0x34, 0x8f, 0xaa, 0x32, 0x48,
+ 0x95, 0x7a, 0xbf, 0x64, 0x19, 0xd2, 0xe3, 0xd3, 0x95, 0x61, 0x5d, 0x93, 0x9f,
+ 0x55, 0x48, 0xe2, 0x1d, 0xe2, 0xb7,
+ ],
+ [
+ 0x80, 0x7b, 0x2b, 0x14, 0xd5, 0x29, 0x31, 0xf3, 0x00, 0xfa, 0x1c, 0x48, 0xe4,
+ 0xea, 0xcc, 0xb7, 0xed, 0x26, 0x17, 0x93, 0xe8, 0x52, 0x9f, 0xf2, 0xc5, 0x3e,
+ 0xc2, 0x14, 0x04, 0xd3, 0xef, 0x9a, 0x3a, 0xb1, 0xe0, 0xb4, 0x13, 0xbb, 0x8c,
+ 0x3c, 0x95, 0x44, 0x2b, 0xa6, 0x02, 0x04, 0x1e, 0x13,
+ ],
+ [
+ 0xc8, 0x92, 0x8b, 0x40, 0xc0, 0x1a, 0xd8, 0xbb, 0x9b, 0xc7, 0x02, 0xd0, 0x43,
+ 0x19, 0xf3, 0xac, 0xdc, 0x88, 0x3a, 0x06, 0x81, 0x85, 0x2e, 0xfb, 0x62, 0x5b,
+ 0x35, 0x38, 0x7f, 0x17, 0x0e, 0xfa, 0x04, 0xe3, 0x54, 0xa9, 0x45, 0xc2, 0x4a,
+ 0x8e, 0x59, 0xf4, 0x23, 0x67, 0x9e, 0x7c, 0xba, 0xda, 0x32, 0xcb, 0xac, 0xe6,
+ 0xbf, 0x7f, 0xd2, 0x32, 0x0c, 0xb4, 0x87, 0xb2, 0xf2, 0x9d, 0x2d, 0x06,
+ ]
+ ),
+ test_case!(
+ [
+ 0xf9, 0x87, 0x3b, 0x77, 0xa7, 0xfd, 0xa1, 0x42, 0xc1, 0xc7, 0x7b, 0xa5, 0x3a,
+ 0x8e, 0xaf, 0x80, 0xf5, 0x97, 0xd5, 0x54, 0xfd, 0xf6, 0xc5, 0xb2, 0xcc, 0xf4,
+ 0x32, 0x74, 0x79, 0x3d, 0xa7, 0x19, 0x91, 0xb9, 0xe3, 0x17, 0xa9, 0xe5, 0x36,
+ 0x7c, 0x3d, 0x5e, 0x9c, 0x75, 0x5d, 0x6f, 0x7d, 0x31, 0x7e, 0xeb, 0xb2, 0x79,
+ 0xe6, 0x90, 0x87, 0x82, 0x8c, 0x9c, 0xa6, 0x7e, 0x9f, 0x5d, 0x6e, 0x63, 0x50,
+ 0x37, 0xd5, 0xaa, 0x69, 0x03, 0x31, 0x30, 0x45, 0x42, 0x78, 0xe7, 0x02, 0xfe,
+ 0x7f,
+ ],
+ [
+ 0x1b, 0x3d, 0x94, 0x2f, 0xf0, 0x45, 0x64, 0x71, 0xad, 0x6e, 0xd1, 0x30, 0x56,
+ 0xea, 0x8d, 0xe1, 0xf0, 0xb0, 0xc1, 0xd9,
+ ],
+ [
+ 0x7f, 0xc2, 0x87, 0x10, 0x9f, 0x66, 0x20, 0x20, 0x1c, 0xcd, 0x68, 0x20, 0x5a,
+ 0x20, 0x72, 0x67, 0xc6, 0x57, 0x39, 0x49, 0xf3, 0x6e, 0xe9, 0x81, 0xd1, 0xee,
+ 0x08, 0xda, 0x7e, 0xa2, 0xf0, 0x87,
+ ],
+ [
+ 0x33, 0x9f, 0x29, 0x4b, 0x71, 0x67, 0x3d, 0x18, 0xd8, 0x82, 0xc7, 0xcd, 0x76,
+ 0x08, 0x81, 0x5b, 0x66, 0x0f, 0x4e, 0x02, 0xc8, 0xb2, 0x1d, 0xef, 0xb0, 0x0e,
+ 0x0f, 0xdf, 0xc8, 0x2e, 0x49, 0x10, 0x1c, 0x0d, 0x75, 0x8a, 0xb5, 0x8c, 0x98,
+ 0x2a, 0x43, 0x2e, 0xfc, 0xc6, 0xab, 0xf9, 0xb4, 0x47,
+ ],
+ [
+ 0x3a, 0x0a, 0xae, 0xe5, 0x11, 0xb8, 0x1f, 0x6a, 0x82, 0x0a, 0x23, 0x2d, 0x55,
+ 0x5f, 0x09, 0xa4, 0x7d, 0x71, 0x28, 0x03, 0xb4, 0xc2, 0x14, 0xee, 0x66, 0x73,
+ 0x9d, 0x44, 0xd9, 0x55, 0x3d, 0xd2, 0x31, 0xc0, 0x58, 0x7d, 0x0a, 0xef, 0xf4,
+ 0xaf, 0xd0, 0x58, 0x34, 0x81, 0x38, 0x32, 0x1c, 0x80, 0xbc, 0xc6, 0xf2, 0xee,
+ 0xad, 0x1a, 0x6f, 0x39, 0x5a, 0xf7, 0x50, 0x02, 0xe7, 0x4c, 0xe1, 0x77,
+ ]
+ ),
+ test_case!(
+ [
+ 0x1a, 0x9a, 0x09, 0x23, 0xe6, 0xa4, 0x56, 0x40, 0xc5, 0xa7, 0x9a, 0x80, 0x4b,
+ 0xa6, 0x12, 0x8d, 0xbf, 0xbc, 0xb8, 0x72, 0xbb, 0x3b, 0x5b, 0x27, 0xde, 0x84,
+ 0xca, 0xc9, 0x7a, 0x10, 0x3e, 0xe3, 0x09, 0x5f, 0xa9, 0x2b, 0x15, 0x5d, 0x44,
+ 0xa8, 0x1e, 0xa7, 0x76, 0xe2, 0x71, 0x9c, 0x0b, 0xa9, 0x2c, 0x28, 0x3b, 0xfd,
+ 0xdb, 0x8b, 0xb5, 0x1c, 0xbf, 0x9a, 0xe0, 0xd4, 0xf2, 0x3c, 0x38, 0xe9, 0x7b,
+ 0x70, 0x1a, 0x0c, 0x1d, 0x90, 0xf8, 0x10, 0xe9, 0x3e, 0x3e, 0x52, 0xde, 0x30,
+ 0x70, 0x17,
+ ],
+ [
+ 0xd0, 0x3a, 0x32, 0x13, 0x38, 0x7a, 0x7c, 0x4d, 0xfc, 0x0a, 0xf4, 0x5c, 0x53,
+ 0x6e, 0x8c, 0x13, 0x23, 0x5b, 0xac, 0x03,
+ ],
+ [
+ 0x26, 0xfd, 0x50, 0x21, 0x71, 0xa6, 0x85, 0xc1, 0xd6, 0x0a, 0xcc, 0xe8, 0x42,
+ 0x9b, 0x05, 0xec, 0xac, 0xe9, 0x1e, 0x86, 0x6c, 0x31, 0x81, 0x75, 0x19, 0x26,
+ 0x18, 0x27, 0xb9, 0xf0, 0x50, 0x0d,
+ ],
+ [
+ 0xe4, 0xbd, 0x4a, 0x00, 0xc0, 0x29, 0x3a, 0xcb, 0x47, 0xa4, 0x63, 0xde, 0xaa,
+ 0x24, 0x51, 0x37, 0xbe, 0x22, 0x8c, 0x23, 0xc9, 0xdd, 0x4c, 0x05, 0x00, 0xfc,
+ 0x41, 0x52, 0xa2, 0xfb, 0x59, 0x63, 0xfe, 0x84, 0xce, 0x4c, 0xe8, 0x20, 0xfe,
+ 0x0f, 0x65, 0xf6, 0x8a, 0xeb, 0x37, 0x13, 0x68, 0xf4,
+ ],
+ [
+ 0x1f, 0x2e, 0x44, 0xb9, 0x04, 0xd3, 0x3f, 0x81, 0x6e, 0x05, 0xd8, 0x4f, 0x5b,
+ 0x6e, 0xa0, 0x82, 0x1e, 0xbc, 0xab, 0x6a, 0xfe, 0xf7, 0xd6, 0xc8, 0x52, 0xe4,
+ 0xac, 0xb5, 0xd3, 0xfb, 0xa5, 0x05, 0x64, 0xf0, 0x77, 0xbb, 0x48, 0xa5, 0xf7,
+ 0x49, 0x37, 0x58, 0xb9, 0x2c, 0x99, 0xf9, 0x95, 0x60, 0x94, 0xac, 0x88, 0xef,
+ 0x41, 0x63, 0x6f, 0xec, 0x0f, 0xcd, 0x79, 0x93, 0x05, 0x3c, 0xd2, 0xc3,
+ ]
+ ),
+ test_case!(
+ [
+ 0x6e, 0x3b, 0xda, 0x5c, 0x2f, 0x69, 0x90, 0x1b, 0xf4, 0x49, 0x4c, 0xea, 0x23,
+ 0x89, 0x63, 0xd6, 0x95, 0x48, 0x6f, 0x21, 0xfe, 0x25, 0x3b, 0xc9, 0xb6, 0xbe,
+ 0x5b, 0x10, 0x72, 0x3c, 0x1f, 0x5d, 0xf5, 0x91, 0xd2, 0x6e, 0x14, 0xd0, 0x55,
+ 0xe1, 0xa7, 0xc7, 0x2e, 0x82, 0x06, 0x29, 0x40, 0x2f, 0x3b, 0x02, 0x92, 0x7e,
+ 0x72, 0x56, 0x44, 0x50, 0x89, 0xa5, 0xcb, 0xda, 0x66, 0xcf, 0x79, 0xbd, 0xe0,
+ 0x01, 0x39, 0x8e, 0x4d, 0x66, 0xc3, 0xaa, 0xc3, 0xfc, 0x93, 0x46, 0x23, 0x7b,
+ 0xdd, 0x92, 0xf9,
+ ],
+ [
+ 0x05, 0x6f, 0x8a, 0x01, 0xe9, 0xd7, 0x6b, 0xc5, 0xbd, 0xdd, 0x2c, 0xf4, 0xf0,
+ 0xde, 0xdb, 0x2a, 0xed, 0x80, 0xa9, 0x81,
+ ],
+ [
+ 0x87, 0x7a, 0x27, 0xbd, 0x7b, 0xd9, 0x2e, 0xd5, 0x87, 0x99, 0x08, 0x86, 0xd1,
+ 0x7c, 0x44, 0x6a, 0x9c, 0x47, 0x06, 0xa5, 0x2b, 0x69, 0xd7, 0x73, 0x4a, 0x44,
+ 0x2d, 0x11, 0x1e, 0xbe, 0xf4, 0x7f,
+ ],
+ [
+ 0xab, 0x57, 0x46, 0xf9, 0xfd, 0x65, 0x54, 0x52, 0x12, 0x00, 0xbd, 0x54, 0x56,
+ 0x8d, 0x00, 0xbe, 0xfe, 0xe6, 0x63, 0x6c, 0x65, 0x5c, 0x21, 0x47, 0x16, 0x23,
+ 0x01, 0xed, 0xda, 0x15, 0xb1, 0xea, 0x06, 0xdf, 0xdd, 0xa1, 0x44, 0xa9, 0x6c,
+ 0x57, 0x6b, 0x7f, 0x3c, 0xcc, 0xa1, 0xae, 0xd1, 0x81,
+ ],
+ [
+ 0xe0, 0xd7, 0x16, 0x17, 0x3a, 0xc5, 0xc1, 0xf1, 0x5d, 0xed, 0x5e, 0xe7, 0x37,
+ 0x47, 0x06, 0x01, 0x73, 0xa4, 0x29, 0xe5, 0xeb, 0xf6, 0xfa, 0x5c, 0xbe, 0x91,
+ 0x22, 0xf4, 0x44, 0x47, 0x4f, 0xba, 0x92, 0x18, 0x49, 0x42, 0xcd, 0x55, 0x84,
+ 0x24, 0x6b, 0x26, 0xfc, 0x80, 0xee, 0xc5, 0x80, 0xbb, 0x0f, 0xf8, 0x0f, 0xd4,
+ 0x7a, 0x4f, 0x14, 0xa6, 0xc5, 0x13, 0xff, 0xa3, 0x32, 0xed, 0x57, 0x92,
+ ]
+ ),
+ test_case!(
+ [
+ 0xaf, 0xce, 0x16, 0xf3, 0x3a, 0x89, 0xbe, 0xdd, 0x44, 0x7b, 0x3e, 0x74, 0x09,
+ 0x1b, 0x3d, 0x20, 0x02, 0x52, 0x65, 0x60, 0xeb, 0xeb, 0x1f, 0x72, 0x70, 0x32,
+ 0x61, 0xcb, 0x2c, 0xaa, 0x25, 0x40, 0x36, 0x78, 0x27, 0x14, 0x4b, 0x8f, 0x67,
+ 0x2a, 0xd8, 0xcd, 0x13, 0x3c, 0x44, 0xf6, 0x05, 0x11, 0xa0, 0x2e, 0x16, 0x20,
+ 0xa1, 0x88, 0xfc, 0xbe, 0xe8, 0x1b, 0x77, 0x86, 0x6d, 0xa0, 0x39, 0x73, 0xd0,
+ 0x06, 0x22, 0x63, 0xa3, 0xf9, 0xc0, 0xa1, 0x5b, 0x22, 0x71, 0x96, 0xd3, 0x5f,
+ 0xed, 0xbb, 0xd4, 0x00,
+ ],
+ [
+ 0x30, 0x22, 0xb4, 0x8c, 0x5f, 0x18, 0x3f, 0x72, 0x20, 0x1b, 0x5d, 0xf7, 0x3d,
+ 0xd8, 0x3a, 0x85, 0xfb, 0xf0, 0x43, 0x4f,
+ ],
+ [
+ 0x01, 0xb2, 0x31, 0x49, 0x1c, 0xf9, 0x58, 0x54, 0x6b, 0x59, 0x42, 0xbd, 0x21,
+ 0x0c, 0x2c, 0xef, 0xfc, 0xf3, 0x23, 0xb6, 0xc0, 0x5c, 0x75, 0x50, 0x0f, 0x74,
+ 0x4a, 0x68, 0x8d, 0xb9, 0x21, 0x4a,
+ ],
+ [
+ 0x7c, 0x63, 0x89, 0x2d, 0x2f, 0x85, 0x5e, 0xe7, 0x8a, 0x67, 0x46, 0xad, 0xf1,
+ 0x93, 0x54, 0x64, 0x5b, 0x3a, 0x26, 0x40, 0x23, 0x9c, 0xfe, 0x76, 0xa8, 0x04,
+ 0xf8, 0x11, 0x53, 0x2c, 0xd9, 0x54, 0x6c, 0xde, 0xb9, 0xc8, 0xf0, 0x2e, 0x6e,
+ 0xc8, 0x3d, 0xf4, 0x63, 0x34, 0xfe, 0xb7, 0x63, 0x27,
+ ],
+ [
+ 0xa8, 0x05, 0xe0, 0xeb, 0x3e, 0xa2, 0x34, 0x4c, 0x39, 0x39, 0xb8, 0x28, 0x6e,
+ 0xa6, 0x47, 0x26, 0x8c, 0x53, 0x26, 0x3d, 0xc4, 0x3b, 0x47, 0x38, 0x52, 0xa5,
+ 0xbd, 0x74, 0xd0, 0x36, 0xff, 0xaa, 0x2d, 0xf7, 0xd7, 0x10, 0xe7, 0x7b, 0x58,
+ 0x59, 0x2e, 0xe5, 0x96, 0x49, 0x56, 0x11, 0x03, 0x61, 0xeb, 0x26, 0xbd, 0xa9,
+ 0x50, 0x24, 0x3e, 0xbd, 0x10, 0xef, 0x8d, 0x0e, 0x0c, 0x65, 0x2f, 0xb0,
+ ]
+ ),
+ test_case!(
+ [
+ 0x24, 0x74, 0x2b, 0xce, 0xd1, 0x3b, 0x44, 0xf8, 0xc0, 0xd0, 0xd0, 0xc3, 0xe4,
+ 0x11, 0x39, 0x61, 0x80, 0x69, 0xba, 0x5f, 0x04, 0xcc, 0x95, 0xf5, 0xb5, 0x68,
+ 0xae, 0xf8, 0xe9, 0xe9, 0x35, 0x2d, 0x66, 0x06, 0x72, 0x42, 0x1f, 0x34, 0x8c,
+ 0x50, 0xa7, 0x6f, 0xdb, 0x8b, 0xab, 0xa7, 0xac, 0xba, 0xa0, 0x93, 0x62, 0x7d,
+ 0x4b, 0xfe, 0x4a, 0xa6, 0xdd, 0xf0, 0x01, 0x02, 0xd2, 0x6f, 0x94, 0x9a, 0x07,
+ 0x24, 0x16, 0xba, 0x4c, 0xe8, 0xab, 0x0d, 0x43, 0xa5, 0x25, 0x96, 0xbb, 0x9a,
+ 0x38, 0x84, 0x97, 0xc1, 0xf7,
+ ],
+ [
+ 0xb8, 0x74, 0xed, 0x06, 0x84, 0x5c, 0x68, 0x73, 0x97, 0xe2, 0xea, 0x17, 0x5c,
+ 0x14, 0x26, 0x85, 0xa6, 0x50, 0x3a, 0x0c,
+ ],
+ [
+ 0x5e, 0x39, 0x4e, 0x4e, 0x37, 0xa2, 0x05, 0x40, 0x61, 0x95, 0x8d, 0xac, 0xbf,
+ 0x75, 0xcc, 0xc1, 0x14, 0x4d, 0xc8, 0xd8, 0xf9, 0x3f, 0xb7, 0x24, 0x2c, 0x9a,
+ 0xca, 0x3a, 0xe2, 0xae, 0x99, 0x90,
+ ],
+ [
+ 0xe2, 0x71, 0xe9, 0xfc, 0xb2, 0x06, 0x60, 0xc0, 0x4a, 0xeb, 0xca, 0x45, 0xdd,
+ 0x72, 0x83, 0x49, 0xe8, 0xf4, 0x99, 0xb2, 0xcc, 0xc0, 0x36, 0xd7, 0xda, 0xcd,
+ 0xb6, 0xe8, 0xb1, 0xc1, 0x03, 0xcc, 0x9b, 0x10, 0xe4, 0x4e, 0xa4, 0xe5, 0x95,
+ 0xc0, 0xd4, 0x7a, 0xaf, 0x43, 0xd0, 0x33, 0x5a, 0xd0,
+ ],
+ [
+ 0x63, 0xbd, 0x39, 0x1d, 0xd1, 0x46, 0xba, 0x4e, 0xde, 0xad, 0xf4, 0xb0, 0xd9,
+ 0xda, 0x7a, 0xff, 0x90, 0xeb, 0x48, 0x60, 0x5b, 0x7f, 0xd2, 0x9e, 0xbf, 0x2c,
+ 0xaf, 0x54, 0xae, 0x83, 0x7a, 0x5b, 0xfb, 0xf8, 0x25, 0xd0, 0xc5, 0x17, 0x29,
+ 0xac, 0xbd, 0xaf, 0x4e, 0x23, 0xa2, 0x6f, 0x42, 0x73, 0xfc, 0x7b, 0x01, 0x38,
+ 0xa9, 0x42, 0x1d, 0xb9, 0xe8, 0x16, 0xd3, 0xf2, 0xc0, 0xa9, 0x20, 0x9c,
+ ]
+ ),
+ test_case!(
+ [
+ 0xdd, 0x89, 0xd7, 0x92, 0x13, 0xa0, 0xf7, 0xe1, 0x48, 0x3a, 0x4b, 0x14, 0x8d,
+ 0x04, 0xc7, 0x3a, 0xee, 0xad, 0xb3, 0x22, 0x0f, 0x94, 0xa2, 0x76, 0x12, 0x00,
+ 0x38, 0x70, 0x48, 0xf7, 0x8a, 0x98, 0x2a, 0x0f, 0x86, 0x85, 0x10, 0x8e, 0xf8,
+ 0x49, 0xff, 0x8d, 0xff, 0x26, 0xda, 0x55, 0xf0, 0xa8, 0x97, 0x10, 0x3d, 0xc2,
+ 0x79, 0xce, 0x2f, 0x85, 0x21, 0x1a, 0x6b, 0x00, 0x5c, 0xea, 0xbb, 0x82, 0x98,
+ 0x63, 0x66, 0x38, 0xaf, 0x4b, 0xf6, 0xda, 0x03, 0xda, 0xf6, 0xd2, 0xc9, 0x08,
+ 0xa9, 0xdc, 0x26, 0x16, 0x18, 0x96,
+ ],
+ [
+ 0x6f, 0x57, 0xe8, 0x81, 0x52, 0x91, 0x70, 0x0a, 0x47, 0x94, 0x9b, 0x7a, 0x0a,
+ 0xcc, 0x8f, 0x9e, 0x46, 0x75, 0xe5, 0xa0,
+ ],
+ [
+ 0xbc, 0x4f, 0x03, 0xf0, 0x1d, 0x98, 0x9f, 0xec, 0xd0, 0xf4, 0xe6, 0xb3, 0xfa,
+ 0x8b, 0x98, 0x80, 0x4d, 0xba, 0x35, 0x4f, 0xa1, 0x5f, 0x1a, 0x71, 0x84, 0x42,
+ 0x17, 0x57, 0xcb, 0x2d, 0xb4, 0x65,
+ ],
+ [
+ 0xff, 0xc5, 0x61, 0xa9, 0x33, 0x2e, 0xb8, 0x12, 0x0f, 0x67, 0x38, 0x57, 0xde,
+ 0x4a, 0x46, 0x94, 0xbe, 0xae, 0xc7, 0x92, 0xca, 0x06, 0xdc, 0x85, 0xcf, 0xa9,
+ 0xa0, 0xd1, 0xb9, 0xf0, 0x22, 0xbf, 0x02, 0x61, 0x21, 0xf6, 0x64, 0x3a, 0x08,
+ 0x37, 0x7b, 0xed, 0x41, 0x9f, 0x0c, 0x71, 0x93, 0x4f,
+ ],
+ [
+ 0xfb, 0x74, 0x8d, 0x63, 0x78, 0xc6, 0x9a, 0x92, 0xaa, 0xfb, 0x97, 0x0b, 0xcd,
+ 0x29, 0xab, 0x98, 0xe6, 0xda, 0x5e, 0xf7, 0x18, 0xf1, 0x09, 0x0a, 0x04, 0x23,
+ 0x38, 0x2c, 0x10, 0x42, 0x90, 0x2c, 0xaf, 0x1b, 0x7e, 0x50, 0x17, 0x77, 0xac,
+ 0xa0, 0xe0, 0x9e, 0xb5, 0xa4, 0xf9, 0xbb, 0x70, 0x5e, 0x57, 0xf8, 0x2c, 0xb3,
+ 0xa0, 0x3a, 0x2d, 0x70, 0x7e, 0x32, 0x7c, 0xaa, 0x1b, 0xef, 0xd0, 0x3c,
+ ]
+ ),
+ test_case!(
+ [
+ 0x3b, 0x7c, 0xcb, 0x82, 0xa8, 0x15, 0xf2, 0x9f, 0x7b, 0x93, 0x32, 0x1e, 0x76,
+ 0x8e, 0x59, 0x39, 0x81, 0x1a, 0xa9, 0xd3, 0x5e, 0xc5, 0xd6, 0x1a, 0xbf, 0x31,
+ 0x35, 0x91, 0xc3, 0xeb, 0xeb, 0xc5, 0xbb, 0x99, 0xac, 0xc9, 0x5e, 0x67, 0x9c,
+ 0x02, 0x1f, 0x85, 0x4c, 0x7a, 0x10, 0x2b, 0x53, 0x0c, 0x82, 0x18, 0x21, 0x5a,
+ 0x09, 0x80, 0x7c, 0xb7, 0xdf, 0x81, 0x52, 0xa1, 0xe4, 0x05, 0xab, 0xef, 0xd3,
+ 0x21, 0x25, 0x8d, 0xa1, 0x72, 0x00, 0x10, 0x8b, 0xcd, 0xbf, 0x7c, 0xb1, 0x4a,
+ 0x0e, 0x7f, 0x51, 0x5a, 0xe9, 0x75, 0x06,
+ ],
+ [
+ 0x8d, 0x3f, 0xeb, 0x47, 0x2e, 0xfd, 0x02, 0x3f, 0x2b, 0x20, 0x22, 0x41, 0x6d,
+ 0x47, 0xf1, 0xf5, 0x4b, 0x8e, 0x18, 0xbf,
+ ],
+ [
+ 0x20, 0x10, 0xab, 0x80, 0x10, 0x4e, 0x64, 0x12, 0xe0, 0x59, 0x02, 0x23, 0xd4,
+ 0xb1, 0x38, 0x10, 0xf0, 0x54, 0xf4, 0xfa, 0x52, 0xdd, 0x9c, 0x10, 0x17, 0x62,
+ 0x8f, 0x5a, 0x30, 0x8e, 0x8f, 0x77,
+ ],
+ [
+ 0x27, 0x03, 0xbe, 0x2e, 0x01, 0xb2, 0x45, 0xf5, 0x79, 0xc9, 0xa4, 0x00, 0xdb,
+ 0xdc, 0x9e, 0x16, 0x59, 0xdd, 0xb2, 0x9e, 0xf5, 0xe7, 0x8a, 0xb7, 0x21, 0xb4,
+ 0x83, 0xf7, 0xb2, 0x33, 0x70, 0x21, 0x28, 0x40, 0x3e, 0x3c, 0xdf, 0xfe, 0x3b,
+ 0x47, 0x04, 0x9e, 0x89, 0xef, 0x26, 0x75, 0x36, 0xc9,
+ ],
+ [
+ 0x44, 0x09, 0x79, 0x6e, 0xf4, 0x46, 0xa3, 0xad, 0x04, 0xd6, 0x21, 0xbb, 0x2a,
+ 0x6b, 0x22, 0xc4, 0x88, 0xca, 0xc2, 0xc5, 0xe2, 0x0f, 0x75, 0x74, 0x87, 0xaa,
+ 0x1b, 0xd3, 0xc4, 0x93, 0xd2, 0x7c, 0x24, 0x6d, 0x27, 0x53, 0x5f, 0xc0, 0xa2,
+ 0x15, 0xe3, 0x7f, 0x46, 0xba, 0x39, 0x08, 0xcf, 0x01, 0x54, 0x95, 0xb4, 0x98,
+ 0x4b, 0x28, 0x9e, 0x0b, 0x87, 0xa1, 0xa1, 0xc9, 0x0d, 0x4c, 0x2b, 0x19,
+ ]
+ ),
+ test_case!(
+ [
+ 0xb1, 0xc5, 0x05, 0x68, 0xf3, 0x5a, 0xcd, 0x3a, 0xd6, 0x64, 0x7b, 0x9f, 0x0e,
+ 0xe9, 0x6d, 0x1b, 0xa4, 0xd9, 0x29, 0xc7, 0xa5, 0x63, 0xf7, 0xe6, 0x28, 0x5c,
+ 0x7d, 0x44, 0x85, 0xc5, 0xde, 0x59, 0xf7, 0x0c, 0x40, 0x2a, 0x36, 0x4c, 0x38,
+ 0x7b, 0x40, 0x9d, 0xf7, 0xff, 0xe3, 0xb1, 0x0a, 0xe9, 0x4e, 0x85, 0x06, 0xad,
+ 0x8d, 0x61, 0x21, 0xb2, 0x1f, 0xab, 0x82, 0xc4, 0xaa, 0xa5, 0x12, 0xf9, 0xfe,
+ 0x41, 0x3c, 0xab, 0x5e, 0xcd, 0x94, 0x6e, 0x27, 0x78, 0x08, 0x65, 0xe9, 0x0a,
+ 0x2e, 0x56, 0x66, 0xc5, 0xbb, 0xd1, 0xd2, 0x4e,
+ ],
+ [
+ 0xa7, 0x6f, 0x58, 0x3e, 0xa3, 0x3c, 0x1d, 0xb9, 0x1e, 0xb6, 0xf0, 0x66, 0x40,
+ 0x59, 0x1d, 0xdb, 0xdf, 0xfb, 0x6c, 0x61,
+ ],
+ [
+ 0x82, 0xe5, 0x96, 0x58, 0x93, 0xad, 0x82, 0x74, 0x80, 0xb9, 0xfa, 0x58, 0xfa,
+ 0xae, 0x18, 0x54, 0x3f, 0xa3, 0x44, 0x27, 0x93, 0xa9, 0xa1, 0xa0, 0xd9, 0x08,
+ 0xcb, 0x3b, 0xa8, 0x66, 0x7d, 0x2a,
+ ],
+ [
+ 0xea, 0xcd, 0x4a, 0xeb, 0x89, 0xd5, 0xfb, 0xd1, 0x46, 0x2a, 0x53, 0x5a, 0x52,
+ 0xd9, 0xcf, 0xc8, 0x3a, 0x25, 0xfd, 0xfa, 0x35, 0xa0, 0x46, 0xb7, 0x9c, 0x13,
+ 0x9a, 0x90, 0x06, 0x1c, 0x2f, 0x1e, 0x23, 0x25, 0xb2, 0x50, 0x85, 0x03, 0x69,
+ 0x9a, 0x5e, 0x22, 0x78, 0x89, 0x82, 0x76, 0x5f, 0x4d,
+ ],
+ [
+ 0xd8, 0x19, 0x7b, 0x1e, 0x45, 0x6b, 0xbb, 0x03, 0x27, 0x34, 0xf5, 0xe4, 0xd7,
+ 0x78, 0x31, 0x4a, 0x12, 0x2d, 0x45, 0xbc, 0x93, 0x81, 0xeb, 0xfb, 0x9b, 0x07,
+ 0x4d, 0xd0, 0x52, 0x49, 0x0c, 0xf3, 0x5d, 0x28, 0xd5, 0xfe, 0xfa, 0xa8, 0x32,
+ 0x12, 0x47, 0x7f, 0x75, 0xc5, 0x03, 0xe1, 0x5c, 0x71, 0x97, 0xaf, 0xe1, 0x0f,
+ 0xc4, 0x80, 0xcc, 0xbf, 0x5a, 0x70, 0xd8, 0x89, 0xe2, 0xb7, 0x9c, 0x23,
+ ]
+ ),
+ test_case!(
+ [
+ 0x68, 0x52, 0x52, 0x63, 0x7a, 0xe5, 0xa6, 0xf2, 0x2a, 0x48, 0x32, 0xe6, 0xc6,
+ 0xb9, 0xed, 0x30, 0x94, 0x86, 0xe6, 0x9e, 0x30, 0xba, 0x38, 0xaf, 0xcf, 0x0f,
+ 0xe0, 0x4f, 0xfd, 0x23, 0xa3, 0x49, 0x02, 0x89, 0xfe, 0xdd, 0xac, 0x56, 0xe9,
+ 0xcc, 0xf9, 0xcb, 0x69, 0x27, 0xb1, 0x8c, 0x52, 0x30, 0xa9, 0xdb, 0xad, 0x64,
+ 0xca, 0xef, 0x36, 0x8f, 0x83, 0x10, 0xd8, 0x27, 0x5d, 0x87, 0x4a, 0x4a, 0x54,
+ 0x6e, 0xcc, 0x4b, 0x01, 0x10, 0x4f, 0x18, 0x8d, 0xc6, 0x71, 0x63, 0x99, 0xd9,
+ 0x1b, 0xab, 0xbf, 0x5e, 0xd6, 0xae, 0x1d, 0xe7, 0x8c,
+ ],
+ [
+ 0x1a, 0x98, 0x3d, 0xa0, 0xe0, 0x65, 0xb3, 0x49, 0x37, 0x73, 0xd6, 0xab, 0x88,
+ 0xf1, 0x9e, 0xe7, 0x11, 0x92, 0xfe, 0x2f,
+ ],
+ [
+ 0x2b, 0x63, 0x5e, 0x04, 0x99, 0xde, 0x2d, 0xc9, 0x0d, 0xa0, 0xca, 0x9c, 0xc9,
+ 0xfc, 0xd6, 0x72, 0xc6, 0x76, 0xe8, 0xba, 0x5b, 0x60, 0x24, 0x4c, 0x80, 0x52,
+ 0x9d, 0x12, 0x46, 0x8b, 0xe0, 0xe4,
+ ],
+ [
+ 0xe9, 0xdf, 0x02, 0x76, 0x61, 0x50, 0xad, 0x9e, 0xa6, 0xd9, 0x07, 0x5c, 0xae,
+ 0x70, 0x00, 0x58, 0x10, 0x83, 0xdf, 0x3c, 0xf4, 0xf3, 0x30, 0x4b, 0x56, 0xa3,
+ 0x47, 0x00, 0xe8, 0x78, 0x2a, 0x5e, 0x6f, 0x86, 0x84, 0x38, 0x1d, 0x3a, 0xdf,
+ 0x11, 0x4f, 0x13, 0xa0, 0xf2, 0x3e, 0x6e, 0x58, 0xdf,
+ ],
+ [
+ 0xac, 0x23, 0xc2, 0x5a, 0x3f, 0x10, 0x1f, 0x78, 0x68, 0xe0, 0x67, 0x2b, 0xdf,
+ 0x51, 0xfa, 0xb6, 0x2e, 0x06, 0x21, 0x26, 0x21, 0x3f, 0xd8, 0xb7, 0x7e, 0x88,
+ 0x00, 0xda, 0xa2, 0x71, 0xf5, 0x09, 0x18, 0xe7, 0xc5, 0xfc, 0xb1, 0x97, 0x2a,
+ 0x46, 0xb9, 0x4f, 0x74, 0x92, 0x8d, 0xbb, 0xa6, 0x1c, 0xcf, 0x7e, 0x39, 0x91,
+ 0xe8, 0x1a, 0x68, 0x8e, 0x63, 0xaa, 0x5a, 0xcd, 0xc6, 0x7b, 0x27, 0x09,
+ ]
+ ),
+ test_case!(
+ [
+ 0x50, 0xc7, 0x6d, 0x59, 0x4d, 0x87, 0x71, 0x96, 0x16, 0x17, 0xeb, 0xb8, 0xf8,
+ 0x07, 0xb4, 0xda, 0xd7, 0xb3, 0x7b, 0xf1, 0x8c, 0x6d, 0x75, 0x85, 0xd7, 0x1d,
+ 0xc5, 0x29, 0x38, 0x00, 0xd5, 0x95, 0x87, 0x10, 0xd4, 0x1f, 0x0b, 0x93, 0x49,
+ 0xe2, 0xe7, 0xa1, 0x5c, 0xf5, 0xaa, 0x66, 0x5b, 0xb3, 0x7c, 0x2e, 0x66, 0xa6,
+ 0xa8, 0xcc, 0xaf, 0xc2, 0xaa, 0xfa, 0x6f, 0xf6, 0x27, 0xc7, 0x7f, 0xab, 0xee,
+ 0x67, 0x38, 0x2e, 0x19, 0xeb, 0xac, 0x07, 0x87, 0x22, 0x85, 0xc6, 0x5d, 0x62,
+ 0x9c, 0x52, 0x34, 0x21, 0x80, 0xdf, 0x5c, 0x3d, 0x69, 0x9f,
+ ],
+ [
+ 0x98, 0x5b, 0xb6, 0x6e, 0x2c, 0xc0, 0x38, 0xe1, 0xb0, 0x5f, 0x78, 0xbc, 0x44,
+ 0xf0, 0xd9, 0xc3, 0xa9, 0xc8, 0x35, 0x30,
+ ],
+ [
+ 0xab, 0x3a, 0x81, 0x65, 0xbe, 0x03, 0xe3, 0x96, 0x80, 0xbb, 0x7f, 0xc6, 0x53,
+ 0x38, 0x48, 0x75, 0x53, 0xfa, 0x7f, 0xa2, 0xfc, 0x3b, 0xe9, 0xa1, 0xec, 0xe8,
+ 0xf0, 0x5c, 0xf0, 0x70, 0x79, 0x82,
+ ],
+ [
+ 0x73, 0x00, 0x9f, 0x94, 0x7a, 0xea, 0x04, 0xcf, 0x4f, 0x4d, 0x57, 0xe9, 0xad,
+ 0xf7, 0xe3, 0x07, 0x66, 0xc1, 0x36, 0xe0, 0x05, 0x75, 0xe9, 0x97, 0x00, 0x6e,
+ 0x07, 0xec, 0xe4, 0xd8, 0x29, 0x07, 0x27, 0xf1, 0x42, 0xdd, 0x45, 0xc9, 0xa3,
+ 0x29, 0x9c, 0x5e, 0x1c, 0x5a, 0x33, 0x05, 0xe2, 0x7d,
+ ],
+ [
+ 0x16, 0x8b, 0x4b, 0x18, 0xb8, 0x6d, 0x8b, 0x17, 0x77, 0x61, 0xa8, 0xe3, 0x38,
+ 0x71, 0x58, 0x47, 0x40, 0x39, 0x0e, 0x63, 0xa7, 0xbd, 0xd8, 0x87, 0x36, 0xfa,
+ 0x16, 0xa8, 0x86, 0x88, 0xef, 0x2e, 0xb3, 0x2d, 0xcc, 0xf6, 0xd2, 0x9e, 0x09,
+ 0xab, 0xf0, 0x75, 0xf7, 0x3d, 0x46, 0xe0, 0x2c, 0x09, 0x18, 0x76, 0x74, 0xfd,
+ 0xb9, 0xa4, 0x80, 0xd8, 0x60, 0x1f, 0xc6, 0x0c, 0xb4, 0xc9, 0x45, 0xa9,
+ ]
+ ),
+ test_case!(
+ [
+ 0x3d, 0x4d, 0x10, 0xb4, 0xbb, 0x6a, 0xed, 0x74, 0x4a, 0xeb, 0xf0, 0x64, 0x45,
+ 0x24, 0x15, 0x5f, 0xaf, 0xdf, 0x77, 0xb4, 0xf9, 0x0a, 0xfd, 0x4c, 0x4c, 0x3d,
+ 0x6b, 0x87, 0x7a, 0x78, 0xe6, 0x80, 0x1c, 0x65, 0x42, 0xf7, 0x8c, 0xbe, 0xb3,
+ 0xb3, 0x4b, 0x65, 0xc0, 0xa3, 0x5e, 0x4a, 0x12, 0xda, 0x34, 0x57, 0xed, 0x8a,
+ 0xdc, 0x5c, 0xb8, 0x68, 0xd3, 0x0d, 0xca, 0xf3, 0xd8, 0xe9, 0xd6, 0x51, 0x3e,
+ 0x4e, 0xc6, 0xc8, 0x1a, 0x93, 0x95, 0xa5, 0x82, 0x35, 0xbc, 0x73, 0xdc, 0x09,
+ 0x42, 0xb7, 0x7e, 0x96, 0xb8, 0xf4, 0x20, 0x95, 0x0a, 0x64, 0x5d,
+ ],
+ [
+ 0x57, 0x04, 0x84, 0x3e, 0xe2, 0x4f, 0x33, 0x37, 0x6f, 0x42, 0xf9, 0xa2, 0x6f,
+ 0xcf, 0x63, 0xe6, 0x35, 0xf5, 0xcf, 0x88,
+ ],
+ [
+ 0x5b, 0x48, 0x0c, 0xe1, 0x2e, 0x67, 0xc3, 0x1b, 0xf8, 0xb1, 0xe9, 0x9e, 0x4c,
+ 0x1e, 0x57, 0xad, 0x3d, 0xb3, 0xa1, 0xe4, 0xb1, 0x16, 0x2b, 0xc5, 0x54, 0x12,
+ 0x17, 0x70, 0xe6, 0xaa, 0xfe, 0x86,
+ ],
+ [
+ 0xb2, 0xc2, 0x3c, 0x73, 0x8c, 0xc2, 0x3d, 0x76, 0x63, 0x14, 0xb0, 0xd2, 0x84,
+ 0x83, 0x34, 0xe3, 0xb0, 0x38, 0x3f, 0xc9, 0x64, 0xb0, 0xf6, 0x3e, 0x49, 0x53,
+ 0xec, 0x4d, 0xdc, 0xbc, 0xbf, 0x6d, 0x27, 0x8c, 0x1b, 0x69, 0x3a, 0xd6, 0xe6,
+ 0xc7, 0xc2, 0x7f, 0xc4, 0x9f, 0xee, 0xf1, 0xb2, 0xeb,
+ ],
+ [
+ 0x17, 0x65, 0x12, 0x21, 0x3e, 0x00, 0xb1, 0x52, 0x26, 0x23, 0xc8, 0x7d, 0x17,
+ 0x3c, 0x5e, 0x43, 0xe2, 0x9c, 0xc2, 0x57, 0x48, 0xa9, 0x7d, 0x86, 0x43, 0x88,
+ 0x97, 0x46, 0x58, 0xb7, 0x78, 0x29, 0x93, 0x0a, 0x42, 0x47, 0xff, 0x23, 0x42,
+ 0x20, 0xcf, 0x4b, 0x22, 0xb7, 0x10, 0xe1, 0x8c, 0x49, 0x11, 0x48, 0x4a, 0xb0,
+ 0x95, 0x86, 0x1c, 0x2e, 0x1b, 0x27, 0xce, 0x4e, 0x42, 0xc6, 0xc2, 0x78,
+ ]
+ ),
+ test_case!(
+ [
+ 0xf2, 0xd7, 0x9b, 0x37, 0x30, 0x67, 0x67, 0x69, 0x7e, 0x54, 0xc7, 0xc7, 0x84,
+ 0xc1, 0xd5, 0xc2, 0x72, 0x18, 0x66, 0x2f, 0x5a, 0x79, 0x27, 0xd1, 0x7a, 0x61,
+ 0x3c, 0xfc, 0xc8, 0x13, 0xa1, 0xc2, 0x01, 0x1d, 0xa1, 0xec, 0xba, 0xe5, 0xa3,
+ 0x23, 0x6a, 0xd5, 0xaf, 0xf1, 0x26, 0x03, 0x8d, 0x97, 0xee, 0x71, 0xac, 0xd5,
+ 0xbb, 0x34, 0xcd, 0x3e, 0x55, 0x18, 0xa6, 0x37, 0x11, 0xe1, 0x8b, 0x72, 0x9a,
+ 0x0c, 0x19, 0x13, 0xaf, 0x3d, 0x47, 0xae, 0x23, 0x71, 0x41, 0x08, 0x39, 0x28,
+ 0x19, 0xe8, 0x1d, 0x81, 0x1e, 0x72, 0x4d, 0x1b, 0x32, 0x9a, 0xf1, 0xad,
+ ],
+ [
+ 0x95, 0x04, 0xd4, 0x1f, 0x7d, 0x85, 0xa7, 0x38, 0xb8, 0x9e, 0x2d, 0x0f, 0x76,
+ 0x3d, 0x1d, 0x0c, 0xa4, 0xfa, 0xa2, 0x0c,
+ ],
+ [
+ 0x29, 0x67, 0x6d, 0x2d, 0x6b, 0xa3, 0x24, 0x8a, 0x5f, 0xb0, 0x82, 0xd6, 0xd4,
+ 0xb8, 0xb8, 0x69, 0x49, 0x16, 0xc7, 0x74, 0x03, 0x7a, 0x73, 0x3d, 0x3f, 0x0b,
+ 0x50, 0xd8, 0xf5, 0x4f, 0x20, 0x5a,
+ ],
+ [
+ 0x31, 0xb0, 0xa6, 0x44, 0xf2, 0x87, 0x0d, 0x48, 0x1e, 0xfe, 0x0a, 0x57, 0x05,
+ 0xef, 0x90, 0x0a, 0xe7, 0xb8, 0xf1, 0x16, 0x0f, 0x9a, 0x3e, 0xb1, 0x06, 0xd8,
+ 0xba, 0xd8, 0xe2, 0x56, 0xe5, 0xd5, 0x27, 0x25, 0x61, 0x94, 0xe3, 0x98, 0x5b,
+ 0x01, 0xa4, 0x08, 0x0f, 0x63, 0xac, 0xaf, 0x4c, 0xc2,
+ ],
+ [
+ 0x27, 0xf0, 0x97, 0xa3, 0x38, 0xb4, 0x3f, 0x35, 0x61, 0xba, 0x16, 0x4d, 0x2d,
+ 0x56, 0x79, 0x23, 0x34, 0x31, 0x2b, 0x50, 0xbe, 0xf9, 0x90, 0xef, 0x99, 0x47,
+ 0xdb, 0x05, 0xce, 0xec, 0x07, 0xcc, 0x16, 0x5e, 0x91, 0x35, 0xa5, 0x97, 0x7a,
+ 0xa8, 0x8e, 0x6f, 0xc9, 0x59, 0xcb, 0x8e, 0x95, 0x03, 0xc2, 0x28, 0x20, 0x24,
+ 0x7d, 0x0b, 0xbf, 0x12, 0xb3, 0x50, 0xbb, 0xce, 0xca, 0x6d, 0xb9, 0xdc,
+ ]
+ ),
+ test_case!(
+ [
+ 0xa1, 0xd1, 0x9f, 0xf3, 0xac, 0x76, 0xfa, 0x14, 0xed, 0xe0, 0xda, 0x5c, 0x6e,
+ 0x21, 0xca, 0x42, 0xb5, 0xd7, 0x76, 0x0c, 0x4f, 0x95, 0x7e, 0x94, 0xed, 0x6c,
+ 0x3a, 0xf6, 0xdf, 0x8a, 0xe6, 0x79, 0xa1, 0xe1, 0xd7, 0x19, 0x5c, 0x79, 0x6c,
+ 0xdb, 0x9f, 0xb8, 0x45, 0x7d, 0xd9, 0xca, 0x4d, 0xc8, 0x46, 0x15, 0x7e, 0xb5,
+ 0x76, 0x9b, 0x18, 0xca, 0xba, 0xbb, 0x34, 0x23, 0x28, 0x4d, 0x9c, 0x4b, 0x5c,
+ 0x66, 0x8c, 0x0f, 0x1d, 0xab, 0xaa, 0x43, 0x47, 0x49, 0x26, 0x82, 0xb5, 0xb2,
+ 0x2b, 0x6a, 0xa5, 0xf7, 0x41, 0xce, 0x68, 0x79, 0x77, 0xe1, 0x08, 0x93, 0xbe,
+ ],
+ [
+ 0xa4, 0x05, 0x71, 0x6f, 0x05, 0xbf, 0xf0, 0xfa, 0x1a, 0x21, 0x6f, 0xbf, 0xf2,
+ 0x82, 0xbd, 0x33, 0x89, 0xed, 0xb7, 0xc3,
+ ],
+ [
+ 0x6c, 0x0b, 0x97, 0xdf, 0xb9, 0x30, 0xbc, 0x3d, 0x16, 0x69, 0x0b, 0x6f, 0xcc,
+ 0x50, 0xcf, 0xa3, 0x5d, 0x31, 0xea, 0x45, 0xd7, 0x2f, 0xb6, 0x93, 0xb3, 0xbe,
+ 0x54, 0xe6, 0x13, 0xc3, 0x0b, 0xf2,
+ ],
+ [
+ 0x52, 0x62, 0xa3, 0xbe, 0xe4, 0xe7, 0x2d, 0x69, 0x20, 0x4b, 0xda, 0x36, 0x5d,
+ 0x09, 0xa8, 0x09, 0xc2, 0x3f, 0x84, 0x77, 0x9f, 0xdd, 0x09, 0xfb, 0x08, 0x3a,
+ 0xbe, 0x9d, 0x5c, 0x71, 0xa2, 0xf2, 0xf0, 0xf3, 0xe3, 0x41, 0xa9, 0xec, 0x19,
+ 0x28, 0xaf, 0xa8, 0x58, 0x7f, 0xb5, 0x92, 0x2f, 0xdd,
+ ],
+ [
+ 0x6e, 0xdd, 0x39, 0x65, 0x40, 0x81, 0x2f, 0x01, 0x34, 0x14, 0x9b, 0xa9, 0xb0,
+ 0x70, 0xdf, 0xa5, 0x23, 0xbe, 0x43, 0xb4, 0xb9, 0x16, 0x10, 0x87, 0x75, 0x41,
+ 0x85, 0x9a, 0xfe, 0x9c, 0xc3, 0xc0, 0x5f, 0xf2, 0x8a, 0xf1, 0xc2, 0x1c, 0xba,
+ 0x40, 0x2c, 0x80, 0x78, 0x5b, 0x75, 0x41, 0x31, 0xfa, 0xa3, 0xc4, 0x06, 0x5b,
+ 0x55, 0x79, 0x2f, 0x65, 0x82, 0x29, 0x58, 0x75, 0xf5, 0x58, 0xc5, 0x86,
+ ]
+ ),
+ test_case!(
+ [
+ 0x9f, 0xd7, 0xcb, 0x9d, 0x11, 0x2c, 0xe5, 0x40, 0x9a, 0xfb, 0x0b, 0xf0, 0x97,
+ 0x8c, 0x46, 0xb0, 0xb3, 0x4a, 0x73, 0xb3, 0xa9, 0xac, 0xb0, 0xc8, 0x0e, 0x54,
+ 0x15, 0xa5, 0x2b, 0x0f, 0xae, 0xfd, 0x41, 0xf1, 0xd4, 0xae, 0xdd, 0xb5, 0x95,
+ 0x2a, 0x26, 0xb1, 0x66, 0x1b, 0x75, 0x3b, 0x87, 0x10, 0x39, 0xbe, 0xec, 0x04,
+ 0x30, 0xe1, 0x83, 0xe7, 0x4a, 0x2c, 0x0c, 0xb1, 0xee, 0x8d, 0x6b, 0xe3, 0x90,
+ 0x5c, 0x34, 0xa8, 0xe9, 0x21, 0xd0, 0xc7, 0x68, 0x5b, 0xc6, 0x55, 0xc0, 0x33,
+ 0x27, 0xc6, 0x83, 0xcb, 0x06, 0xb0, 0x6d, 0x39, 0x5a, 0x1c, 0x53, 0xd1, 0xc1,
+ 0x7b,
+ ],
+ [
+ 0xce, 0x45, 0x1f, 0xc7, 0xa4, 0xd9, 0x11, 0x41, 0x3f, 0x92, 0xd2, 0x86, 0x32,
+ 0x49, 0x39, 0xcc, 0xeb, 0xaa, 0x8d, 0x29,
+ ],
+ [
+ 0xd4, 0x41, 0x28, 0xd6, 0xe9, 0x8a, 0xa6, 0x8a, 0xa3, 0x4b, 0x56, 0x02, 0xb5,
+ 0x54, 0xf3, 0xc2, 0x63, 0xfd, 0x42, 0x2f, 0x2d, 0x2b, 0x72, 0x87, 0xf7, 0x34,
+ 0xb1, 0xb0, 0x10, 0x6b, 0xf3, 0xa5,
+ ],
+ [
+ 0x64, 0xaa, 0x62, 0x6d, 0x73, 0x02, 0x32, 0xec, 0x4d, 0x5c, 0x4f, 0x5a, 0x00,
+ 0x43, 0xd1, 0x36, 0x29, 0xd1, 0x2f, 0xb3, 0x86, 0x52, 0x85, 0x97, 0x23, 0x22,
+ 0x72, 0x51, 0xa0, 0xbd, 0x8c, 0x79, 0x04, 0xa4, 0x22, 0x61, 0x28, 0x67, 0x9a,
+ 0x64, 0x00, 0x89, 0x55, 0xc7, 0xc2, 0x3f, 0x25, 0xe1,
+ ],
+ [
+ 0xc1, 0xda, 0x78, 0xfe, 0xef, 0xc0, 0x3b, 0xc7, 0xaa, 0xab, 0x69, 0x63, 0x94,
+ 0x16, 0x0d, 0x05, 0xac, 0x17, 0xf2, 0xd8, 0x27, 0x4b, 0x1c, 0xa9, 0x1f, 0x3d,
+ 0xbd, 0x92, 0x81, 0xe5, 0x29, 0x51, 0x61, 0x05, 0x6d, 0x13, 0x45, 0x41, 0xc7,
+ 0x75, 0x29, 0xbe, 0x7b, 0x84, 0xd7, 0x3d, 0x76, 0xb1, 0x09, 0xec, 0xf7, 0x25,
+ 0x20, 0xa2, 0x2f, 0xef, 0xa6, 0x91, 0xe4, 0xe3, 0x6c, 0x7d, 0x20, 0x88,
+ ]
+ ),
+ test_case!(
+ [
+ 0x9b, 0x15, 0x79, 0xa0, 0x52, 0xd9, 0xa1, 0x06, 0x89, 0xa1, 0x63, 0x17, 0xa8,
+ 0x95, 0xb8, 0x48, 0x23, 0x23, 0xb1, 0x54, 0x3d, 0x83, 0x20, 0xa5, 0x2e, 0xa2,
+ 0xff, 0xde, 0x30, 0x7c, 0xda, 0x29, 0x12, 0x9d, 0x76, 0x35, 0x0c, 0x62, 0x08,
+ 0xc0, 0x5f, 0xb2, 0xb8, 0x4a, 0x32, 0x9a, 0xd2, 0x68, 0xff, 0x9b, 0xc4, 0xa4,
+ 0x22, 0xae, 0x06, 0xbf, 0x00, 0x78, 0x37, 0x92, 0xce, 0xde, 0x1a, 0xf2, 0xbd,
+ 0x52, 0xac, 0xe5, 0x06, 0xba, 0xe2, 0x8f, 0xff, 0x87, 0xe7, 0xda, 0x8c, 0x6c,
+ 0xcb, 0xb4, 0xad, 0xfa, 0x8d, 0x94, 0xce, 0xdb, 0x5a, 0xe0, 0xee, 0xbc, 0x5b,
+ 0x61, 0x4b,
+ ],
+ [
+ 0x1b, 0xf2, 0x3c, 0x86, 0x4e, 0x2d, 0x47, 0x18, 0xf8, 0xbf, 0x6e, 0x47, 0x1f,
+ 0x40, 0x64, 0xaf, 0xb8, 0xaa, 0xc6, 0xda,
+ ],
+ [
+ 0x11, 0x71, 0x41, 0x3a, 0x6b, 0x37, 0xf1, 0x21, 0x10, 0xe8, 0xa8, 0xe5, 0x9a,
+ 0x56, 0xce, 0xd8, 0xb2, 0xdc, 0xff, 0xd7, 0xe7, 0x3f, 0xe8, 0x42, 0x90, 0x45,
+ 0x26, 0x85, 0x0b, 0xd6, 0xe0, 0xb4,
+ ],
+ [
+ 0x45, 0xa4, 0x20, 0x6b, 0x1d, 0x0e, 0xc7, 0x42, 0x18, 0xf5, 0x01, 0xc4, 0xdb,
+ 0x04, 0x7f, 0x00, 0x04, 0xfc, 0xcb, 0x62, 0x5f, 0x7b, 0x9d, 0x47, 0x56, 0xef,
+ 0x52, 0x18, 0xab, 0xb1, 0x1a, 0x5e, 0x7f, 0xac, 0x62, 0xb4, 0xd5, 0x1c, 0x0c,
+ 0x6c, 0xbd, 0xcf, 0xf7, 0x27, 0x85, 0x1a, 0xd2, 0x6d,
+ ],
+ [
+ 0x6b, 0x70, 0x22, 0x94, 0x99, 0x8a, 0x37, 0x52, 0x81, 0xa3, 0x56, 0x64, 0x25,
+ 0x0c, 0xc8, 0xfd, 0x6f, 0x9e, 0x72, 0xa7, 0xd2, 0x3d, 0x46, 0xa0, 0xb7, 0xe8,
+ 0x6f, 0x5c, 0xef, 0x4f, 0xec, 0x75, 0x99, 0x1e, 0x5f, 0xc6, 0xd1, 0xd2, 0x38,
+ 0x45, 0x37, 0xfa, 0x3f, 0xef, 0x1f, 0xda, 0x8b, 0xce, 0x14, 0x32, 0x58, 0x63,
+ 0x3e, 0x3f, 0xfa, 0x22, 0x38, 0xbd, 0x52, 0xd8, 0x69, 0xa6, 0x15, 0x2e,
+ ]
+ ),
+ test_case!(
+ [
+ 0xf8, 0xb6, 0x35, 0x4e, 0x4f, 0x7a, 0xd2, 0x6f, 0xe5, 0x4f, 0x0c, 0x3a, 0xb0,
+ 0xe9, 0xe4, 0x70, 0x8f, 0x0a, 0x06, 0x32, 0x8b, 0xdb, 0xcb, 0xd8, 0x0a, 0x64,
+ 0x3a, 0x87, 0xbb, 0x41, 0x5f, 0xfe, 0x53, 0xd4, 0x48, 0xb2, 0xd6, 0xf0, 0x48,
+ 0x98, 0xf0, 0xc7, 0xb4, 0x92, 0x58, 0xbc, 0xbe, 0x88, 0xe2, 0x2f, 0xb8, 0x39,
+ 0x15, 0xce, 0x5e, 0xce, 0xb1, 0x7f, 0x39, 0xc5, 0x81, 0x27, 0x10, 0xc8, 0xbb,
+ 0x3a, 0x79, 0x02, 0xb1, 0xd2, 0xd5, 0x5a, 0x69, 0x48, 0xbf, 0xb3, 0xe8, 0x58,
+ 0xd3, 0x3b, 0xf4, 0xea, 0x26, 0xc6, 0xe4, 0x62, 0x64, 0xad, 0x5d, 0x6a, 0x36,
+ 0x51, 0x98, 0x53,
+ ],
+ [
+ 0x65, 0x08, 0xb9, 0x99, 0xe6, 0xda, 0xd1, 0xd9, 0xd6, 0xae, 0xa4, 0xe2, 0x04,
+ 0xfe, 0xc3, 0xa6, 0xdc, 0x1a, 0x6c, 0x66,
+ ],
+ [
+ 0x95, 0x79, 0x52, 0x84, 0xe7, 0xb8, 0xf2, 0x77, 0x1c, 0x80, 0x02, 0x4f, 0xe1,
+ 0xaa, 0xd8, 0x5b, 0x01, 0xe9, 0x04, 0x4b, 0xf2, 0xe0, 0x2f, 0x8d, 0x6e, 0xad,
+ 0x82, 0x42, 0x9d, 0xef, 0x7e, 0x42,
+ ],
+ [
+ 0xf5, 0x54, 0xd4, 0xe1, 0x1d, 0xca, 0xde, 0xd3, 0x31, 0xae, 0x1f, 0x88, 0x6e,
+ 0x57, 0xc1, 0x56, 0xfd, 0x4a, 0x47, 0x3d, 0xba, 0x2c, 0x05, 0x84, 0x65, 0x3c,
+ 0x7a, 0x31, 0x58, 0xf7, 0xa2, 0x07, 0x1f, 0x7b, 0xd2, 0x2b, 0x39, 0xd2, 0x30,
+ 0x8f, 0xf1, 0x1a, 0x1f, 0x6a, 0x99, 0xd1, 0x8e, 0x72,
+ ],
+ [
+ 0x2f, 0xdd, 0x3c, 0x16, 0xf8, 0x02, 0x92, 0xca, 0x04, 0xe6, 0xe1, 0x70, 0x20,
+ 0xd1, 0x23, 0x9c, 0xc7, 0xe6, 0x72, 0x41, 0xef, 0x88, 0xc4, 0x4a, 0x62, 0x55,
+ 0x0e, 0x44, 0xcf, 0x06, 0x21, 0xea, 0xc1, 0x42, 0x07, 0x4c, 0x31, 0x0f, 0x67,
+ 0x10, 0x44, 0x42, 0x96, 0xbb, 0x03, 0xbf, 0x2a, 0xe8, 0xd8, 0x72, 0x29, 0x8c,
+ 0x62, 0xed, 0xfa, 0xad, 0x97, 0x73, 0x93, 0x06, 0xb3, 0x4f, 0x8a, 0xe5,
+ ]
+ ),
+ test_case!(
+ [
+ 0x9e, 0x58, 0x76, 0x45, 0xb7, 0x0c, 0xad, 0xf0, 0x93, 0xf1, 0x11, 0x66, 0x58,
+ 0x49, 0xe4, 0x5c, 0x62, 0x8c, 0x79, 0x13, 0x10, 0x5b, 0xa4, 0xc2, 0x2e, 0x31,
+ 0x40, 0x94, 0x7e, 0x11, 0xde, 0x90, 0xa0, 0x5e, 0xe1, 0x68, 0x9b, 0x5d, 0xd9,
+ 0xe9, 0xb5, 0xc1, 0x15, 0x2a, 0xf2, 0xfd, 0x4c, 0xc6, 0x38, 0xaa, 0xad, 0x51,
+ 0x97, 0x1e, 0x85, 0x54, 0xaf, 0x13, 0xfe, 0x82, 0x2e, 0xa0, 0xf2, 0x21, 0x93,
+ 0x9f, 0xf2, 0xec, 0x17, 0x6e, 0xf3, 0x63, 0x5a, 0xc2, 0xef, 0xd1, 0x66, 0x50,
+ 0xcb, 0xfb, 0xea, 0x6e, 0x87, 0xce, 0x8d, 0x60, 0xaf, 0xf4, 0xe4, 0xc2, 0xd5,
+ 0x09, 0x9e, 0x0e, 0xc0,
+ ],
+ [
+ 0xf0, 0x6b, 0x4a, 0xe2, 0x29, 0xc7, 0x09, 0x9a, 0x4c, 0x5a, 0x41, 0xad, 0x7c,
+ 0x22, 0x9a, 0xa9, 0x77, 0xfc, 0x29, 0xd6,
+ ],
+ [
+ 0x63, 0x2b, 0xfd, 0x02, 0xd7, 0xb9, 0x57, 0xa5, 0x89, 0x6d, 0x78, 0xdd, 0x49,
+ 0x1e, 0x57, 0x7b, 0xaa, 0xb9, 0x35, 0xe1, 0x0b, 0x81, 0xcd, 0xa4, 0xbd, 0xdc,
+ 0x13, 0x55, 0x4a, 0x3d, 0xac, 0x1a,
+ ],
+ [
+ 0x62, 0x9d, 0x15, 0xb3, 0x88, 0xbd, 0x51, 0x39, 0x85, 0x6b, 0xbb, 0xa4, 0x05,
+ 0x9d, 0xc7, 0xc7, 0xcc, 0xa4, 0x91, 0x5e, 0x7e, 0x04, 0x85, 0xb2, 0xce, 0x07,
+ 0xf9, 0x97, 0x91, 0x72, 0xf5, 0x42, 0x36, 0x73, 0x19, 0xb8, 0x88, 0x00, 0x66,
+ 0xf2, 0x6b, 0x46, 0x9e, 0xfb, 0xfd, 0xd7, 0xbd, 0x3a,
+ ],
+ [
+ 0x78, 0x48, 0xf2, 0xe6, 0x49, 0xf6, 0x24, 0x81, 0xae, 0x54, 0xdc, 0x17, 0x67,
+ 0xc7, 0x7e, 0x9a, 0x73, 0x8b, 0x3e, 0x53, 0xc5, 0xb4, 0x2e, 0x3c, 0x0e, 0x54,
+ 0x91, 0x07, 0x72, 0xa6, 0x6b, 0x16, 0xb1, 0xfc, 0x83, 0x5a, 0x2c, 0x73, 0x38,
+ 0x8c, 0xed, 0x25, 0x4c, 0xc8, 0x0b, 0x37, 0x20, 0x82, 0xe8, 0x36, 0xf2, 0x90,
+ 0xbb, 0x52, 0x76, 0x2a, 0xa9, 0x68, 0x6d, 0xd9, 0x9d, 0xbf, 0x74, 0x72,
+ ]
+ ),
+ test_case!(
+ [
+ 0xe9, 0xa2, 0x61, 0x9a, 0x31, 0x58, 0xd8, 0xac, 0x3c, 0xa3, 0x92, 0x90, 0xba,
+ 0xa1, 0x97, 0x7b, 0x2e, 0xef, 0xe6, 0xda, 0x10, 0x4e, 0xd7, 0x72, 0xc8, 0xca,
+ 0x24, 0x5d, 0xaf, 0x6d, 0xa1, 0x41, 0x86, 0x17, 0x8b, 0x13, 0x1c, 0x01, 0x2b,
+ 0xa0, 0xa5, 0x08, 0x53, 0xfa, 0x31, 0xef, 0x27, 0x3b, 0x7e, 0x10, 0xaa, 0x80,
+ 0x3f, 0xad, 0x4c, 0xb6, 0x64, 0x0b, 0x71, 0x95, 0x4c, 0xa6, 0xa9, 0x75, 0xe9,
+ 0xe6, 0x95, 0x83, 0x5d, 0x57, 0x8c, 0x3d, 0xd4, 0x4a, 0x6f, 0x2d, 0xac, 0xe2,
+ 0xc9, 0xf3, 0x2a, 0xea, 0xee, 0x0b, 0x44, 0x90, 0x8c, 0x16, 0xd6, 0x01, 0x34,
+ 0x3a, 0x8e, 0x5d, 0x94, 0xbc,
+ ],
+ [
+ 0x48, 0x2f, 0xf5, 0x98, 0x72, 0xf5, 0xe9, 0x3f, 0x89, 0xe5, 0xea, 0x83, 0x6c,
+ 0xe7, 0x7e, 0x06, 0xae, 0x81, 0x52, 0xb3,
+ ],
+ [
+ 0x16, 0x62, 0x2e, 0xa3, 0xa3, 0xd0, 0x5c, 0xb2, 0xb4, 0x5d, 0x7c, 0xf2, 0x81,
+ 0xed, 0x7f, 0x5e, 0xc3, 0x0d, 0xee, 0x92, 0x9f, 0x0a, 0x50, 0x61, 0x5d, 0x36,
+ 0x69, 0x79, 0xd8, 0x0f, 0xc9, 0x0a,
+ ],
+ [
+ 0x0c, 0x1e, 0xa5, 0xfd, 0x87, 0xfb, 0xa0, 0x87, 0xdb, 0x75, 0x40, 0xe2, 0x80,
+ 0x97, 0x1b, 0x94, 0x32, 0x29, 0xc6, 0xb9, 0x68, 0x00, 0x7a, 0x87, 0xdf, 0xa1,
+ 0x3a, 0x00, 0xa2, 0xfc, 0x36, 0x96, 0xbd, 0x16, 0xc2, 0x4f, 0x13, 0xc7, 0xef,
+ 0x7b, 0x36, 0xbf, 0xdb, 0x33, 0xa9, 0xb2, 0x6b, 0xb2,
+ ],
+ [
+ 0xf1, 0xb3, 0x75, 0x86, 0x68, 0xbd, 0x5a, 0x2f, 0x5b, 0x05, 0x3c, 0x80, 0x01,
+ 0x72, 0xf9, 0x80, 0xa8, 0xc3, 0xba, 0x64, 0x5a, 0xcd, 0x0c, 0xca, 0x49, 0x2f,
+ 0x4b, 0xf1, 0x5a, 0x67, 0xcf, 0xd5, 0xae, 0xbf, 0x57, 0xad, 0x66, 0x25, 0xc6,
+ 0x31, 0x47, 0xc2, 0x81, 0x02, 0x45, 0x9b, 0x13, 0x94, 0x87, 0x8c, 0x05, 0x87,
+ 0x8a, 0x41, 0x31, 0x6e, 0x67, 0x0d, 0xac, 0x68, 0x9a, 0xbe, 0xdd, 0xdc,
+ ]
+ ),
+ test_case!(
+ [
+ 0x25, 0xff, 0x04, 0x82, 0x1f, 0xae, 0xd8, 0x58, 0x6e, 0x29, 0xe6, 0xf7, 0x46,
+ 0xa0, 0xad, 0x30, 0xda, 0x97, 0x12, 0xce, 0x64, 0x39, 0xb4, 0xe5, 0xbc, 0xa5,
+ 0xa8, 0xeb, 0xc5, 0xca, 0x2e, 0x11, 0xbf, 0x46, 0x03, 0x87, 0x10, 0x95, 0x3c,
+ 0x55, 0x1a, 0x04, 0xfc, 0xe7, 0xac, 0xfd, 0xc3, 0x30, 0x3f, 0x24, 0x3b, 0x0c,
+ 0xc4, 0x3f, 0x83, 0x6b, 0x08, 0x77, 0x39, 0x6e, 0x0c, 0x05, 0x10, 0xcf, 0x8f,
+ 0xa0, 0x32, 0xa0, 0xed, 0x88, 0x42, 0x4c, 0x65, 0xbb, 0x39, 0xcd, 0x2f, 0x13,
+ 0x88, 0x6b, 0xbc, 0x46, 0x77, 0xdd, 0x98, 0xb7, 0x68, 0x9c, 0xec, 0x5b, 0x68,
+ 0x21, 0x09, 0x9a, 0xb5, 0xd9, 0x1e,
+ ],
+ [
+ 0x90, 0x34, 0xa3, 0x1a, 0xc4, 0xe8, 0xd9, 0xe3, 0x3f, 0x63, 0xe1, 0xd2, 0xe1,
+ 0xbb, 0xf7, 0xf1, 0x06, 0xeb, 0xcd, 0xca,
+ ],
+ [
+ 0xeb, 0x61, 0x9c, 0xc9, 0xf8, 0x0a, 0xfb, 0x28, 0x41, 0x6f, 0xed, 0xbc, 0x8c,
+ 0xaa, 0x9c, 0x03, 0x46, 0xed, 0x7a, 0x3a, 0x83, 0xb6, 0x71, 0xc9, 0xa3, 0x99,
+ 0x0f, 0x69, 0xf7, 0x7f, 0x4c, 0x80,
+ ],
+ [
+ 0x35, 0xd5, 0x9a, 0xcf, 0xd9, 0x6a, 0x71, 0x81, 0x7a, 0xeb, 0x61, 0xec, 0xe3,
+ 0x37, 0xd8, 0x03, 0xeb, 0x0c, 0xda, 0x66, 0xa6, 0x05, 0x80, 0x61, 0x4f, 0x53,
+ 0x20, 0xd2, 0xdd, 0xfc, 0xfa, 0x6a, 0x6e, 0x34, 0xbb, 0x98, 0x91, 0x07, 0x4e,
+ 0xe2, 0x88, 0xd4, 0xbd, 0x9b, 0x2d, 0xf3, 0x3d, 0x62,
+ ],
+ [
+ 0xac, 0x73, 0xae, 0xec, 0x3d, 0x6e, 0x61, 0xf4, 0x71, 0x21, 0x90, 0xa5, 0x92,
+ 0x98, 0x92, 0x75, 0xc0, 0xb7, 0xc2, 0x72, 0xd0, 0x45, 0xcc, 0x7d, 0x1f, 0xf8,
+ 0x28, 0x73, 0xa4, 0xf2, 0xd2, 0x83, 0xa0, 0xa2, 0x3d, 0xd4, 0xfd, 0x1a, 0x90,
+ 0x8f, 0x24, 0x09, 0x45, 0x65, 0x60, 0xeb, 0x2d, 0x5b, 0x1d, 0xbc, 0x5f, 0x26,
+ 0x5d, 0x33, 0x5c, 0xf3, 0xce, 0xa6, 0x3d, 0x98, 0x9f, 0xc6, 0x1c, 0xae,
+ ]
+ ),
+ test_case!(
+ [
+ 0x65, 0x00, 0xdc, 0x9a, 0x79, 0x8c, 0x78, 0xb5, 0x6d, 0x46, 0xd5, 0x64, 0xfc,
+ 0x95, 0xe4, 0x36, 0x17, 0x24, 0xfe, 0x20, 0x74, 0xaf, 0x8e, 0xe0, 0xd9, 0xfa,
+ 0x38, 0x37, 0x8d, 0xc3, 0x62, 0x3e, 0x61, 0xc1, 0x05, 0x52, 0x12, 0x21, 0x38,
+ 0x03, 0x96, 0x9e, 0x38, 0x6f, 0xbb, 0xad, 0x33, 0xe2, 0xea, 0x73, 0x42, 0x0b,
+ 0x33, 0x8a, 0x73, 0x12, 0x0f, 0x43, 0x0a, 0xbf, 0x6d, 0x62, 0xf2, 0xf2, 0xaa,
+ 0x67, 0x04, 0xaf, 0xa7, 0xa8, 0x23, 0x79, 0xce, 0x60, 0xad, 0x49, 0x59, 0xbe,
+ 0x81, 0x26, 0xe7, 0x49, 0x0c, 0xd3, 0x7a, 0xbe, 0xa9, 0x92, 0x35, 0xb6, 0xe5,
+ 0x74, 0x2f, 0x83, 0x2a, 0x45, 0x88, 0xcc,
+ ],
+ [
+ 0x42, 0xde, 0x59, 0x89, 0xb6, 0xe9, 0x5d, 0xb2, 0x3d, 0x99, 0xa9, 0xfd, 0xcf,
+ 0x54, 0x94, 0x6c, 0x37, 0x8d, 0xdf, 0x42,
+ ],
+ [
+ 0x8c, 0x05, 0x33, 0xe5, 0xa2, 0x08, 0x36, 0xf2, 0xdc, 0x71, 0x48, 0x6a, 0x6d,
+ 0x4c, 0x46, 0xa4, 0xe3, 0xc6, 0xda, 0xb7, 0xb2, 0x0c, 0x08, 0x92, 0x27, 0xcf,
+ 0xb1, 0x56, 0xba, 0xfe, 0x3f, 0x4f,
+ ],
+ [
+ 0x92, 0x82, 0x45, 0x5f, 0x18, 0x5d, 0xc0, 0x90, 0x9a, 0xdd, 0x19, 0x46, 0x51,
+ 0xe6, 0x74, 0xbb, 0x00, 0x1e, 0xfb, 0x1e, 0x89, 0x98, 0xf6, 0x33, 0x62, 0xf6,
+ 0xed, 0xee, 0xa4, 0xf5, 0x37, 0xe0, 0x77, 0x5f, 0x46, 0xfd, 0x79, 0x80, 0x97,
+ 0xfc, 0xf3, 0xd2, 0xdb, 0x49, 0x7e, 0xd5, 0x49, 0x09,
+ ],
+ [
+ 0x48, 0x5b, 0xeb, 0xfc, 0x0b, 0xe8, 0x12, 0xc2, 0x8c, 0x1d, 0xbe, 0xf9, 0xa8,
+ 0xa0, 0x89, 0x57, 0xc6, 0x9d, 0xa3, 0x3d, 0x3b, 0x0c, 0x77, 0x2b, 0x93, 0xde,
+ 0xf9, 0xbc, 0x5e, 0xe1, 0x5e, 0xa9, 0xba, 0x7b, 0x3c, 0x19, 0xd0, 0xcf, 0x87,
+ 0x49, 0xff, 0xd7, 0xfa, 0x24, 0x5b, 0x98, 0xca, 0xca, 0x91, 0xff, 0xbd, 0x5c,
+ 0x3d, 0x4f, 0xb9, 0x36, 0x56, 0xda, 0x93, 0xfc, 0x68, 0xd7, 0x6f, 0x21,
+ ]
+ ),
+ test_case!(
+ [
+ 0x4e, 0x91, 0x0e, 0x74, 0x00, 0xe8, 0xe7, 0xa0, 0x94, 0xb1, 0x85, 0x15, 0xef,
+ 0x7f, 0xf4, 0xf4, 0x64, 0xc9, 0xac, 0x6b, 0xca, 0xfe, 0x61, 0xa4, 0xc5, 0x54,
+ 0x41, 0x70, 0xe1, 0x98, 0x85, 0xe5, 0x00, 0x19, 0xd0, 0x60, 0xfe, 0x3e, 0x6b,
+ 0x78, 0x0e, 0xeb, 0x50, 0x15, 0x44, 0x8b, 0x05, 0xa2, 0x85, 0x3c, 0x44, 0x81,
+ 0x04, 0x86, 0x40, 0xd6, 0x1b, 0xf2, 0xc8, 0x2e, 0xbf, 0x5a, 0x1f, 0x7f, 0x40,
+ 0xe8, 0x67, 0x2d, 0x00, 0x75, 0x24, 0x3c, 0x06, 0x8b, 0x79, 0x01, 0xe3, 0x78,
+ 0x9c, 0x9c, 0x20, 0x98, 0x2b, 0x8f, 0x38, 0x14, 0x44, 0x3f, 0xd4, 0xbb, 0x23,
+ 0x15, 0x25, 0x6d, 0x17, 0xcd, 0x22, 0xe5, 0xd2,
+ ],
+ [
+ 0xf4, 0x0e, 0x28, 0x97, 0x5e, 0xda, 0xcd, 0xa1, 0x9c, 0x42, 0xa6, 0xcb, 0x5b,
+ 0x25, 0x41, 0xa5, 0xf8, 0xd1, 0xb4, 0xd7,
+ ],
+ [
+ 0x13, 0xa6, 0xf2, 0x8e, 0x6c, 0x2e, 0x7c, 0xfd, 0x30, 0xf1, 0xb6, 0x90, 0xff,
+ 0x1f, 0x78, 0x9a, 0xe3, 0x8a, 0xd1, 0x8e, 0xd5, 0xae, 0x0a, 0x59, 0xc3, 0xa6,
+ 0x1b, 0xd2, 0x4b, 0xbb, 0x3d, 0xc8,
+ ],
+ [
+ 0x92, 0x8b, 0x01, 0xd8, 0xaa, 0x92, 0x19, 0x84, 0xa8, 0x85, 0xf8, 0x1a, 0x58,
+ 0xc5, 0xcd, 0x56, 0xda, 0xf0, 0x43, 0x04, 0xa1, 0xb1, 0xd3, 0x56, 0xa6, 0x16,
+ 0x12, 0x5c, 0x1a, 0x9a, 0xf4, 0x7f, 0xde, 0x3d, 0x9f, 0xc2, 0xc6, 0x53, 0x66,
+ 0x7e, 0xcd, 0x22, 0x8b, 0xc5, 0x01, 0xfb, 0xef, 0xae,
+ ],
+ [
+ 0xcd, 0x4f, 0xf9, 0x55, 0xd8, 0x4f, 0xfa, 0xe0, 0x76, 0x64, 0x21, 0xcb, 0x06,
+ 0x08, 0xce, 0x62, 0xf2, 0x77, 0xbe, 0xc2, 0x8b, 0xb9, 0x13, 0x22, 0xde, 0x93,
+ 0x1d, 0xf2, 0x22, 0x5a, 0x73, 0x3f, 0xf6, 0xf4, 0x7e, 0x95, 0xf2, 0xae, 0xd4,
+ 0x65, 0x6c, 0x28, 0x3e, 0xb3, 0x89, 0x0a, 0x4e, 0xcd, 0xe0, 0x8e, 0x85, 0xe3,
+ 0x38, 0xdf, 0x67, 0x07, 0xa8, 0x99, 0x70, 0x2f, 0xba, 0x0b, 0x26, 0x80,
+ ]
+ ),
+ test_case!(
+ [
+ 0x4c, 0x31, 0x0f, 0x63, 0x3d, 0xe8, 0xea, 0x29, 0x18, 0x82, 0xb7, 0x25, 0x8c,
+ 0xfa, 0x20, 0xa9, 0x9a, 0xda, 0x85, 0x4c, 0x09, 0x34, 0x0f, 0x64, 0xe7, 0x14,
+ 0x46, 0x37, 0x24, 0x6a, 0xa7, 0xb4, 0xa8, 0x45, 0x98, 0xb4, 0xf4, 0x16, 0x5c,
+ 0x2f, 0xd4, 0x1e, 0x44, 0xc3, 0xbd, 0x7d, 0xb1, 0xea, 0x23, 0x45, 0x1a, 0xaa,
+ 0x44, 0xfb, 0x51, 0xc0, 0x43, 0x94, 0xbe, 0x41, 0x10, 0x4b, 0x9e, 0x05, 0x8c,
+ 0x36, 0xe0, 0xa1, 0x3e, 0xef, 0x3d, 0x12, 0x65, 0x57, 0x80, 0x44, 0x32, 0x4b,
+ 0xbb, 0x55, 0xef, 0x09, 0x93, 0x11, 0xc9, 0x89, 0x9b, 0xcf, 0x2b, 0xad, 0x50,
+ 0xc9, 0x01, 0xb3, 0x72, 0x94, 0xc1, 0x63, 0x77, 0x6a,
+ ],
+ [
+ 0x47, 0x94, 0xaf, 0x2e, 0x2d, 0xe3, 0xbd, 0x70, 0x5d, 0x83, 0x2a, 0x41, 0xeb,
+ 0x89, 0xe8, 0x70, 0xe7, 0x04, 0x9f, 0xa0,
+ ],
+ [
+ 0x2f, 0xc0, 0xab, 0xea, 0x3c, 0xd2, 0xd6, 0x98, 0xa1, 0xb3, 0x90, 0xce, 0xab,
+ 0xcb, 0x0e, 0xa3, 0xd5, 0xd8, 0x6f, 0x9c, 0x1d, 0x50, 0x6c, 0xdb, 0xfd, 0x1c,
+ 0x0c, 0xc7, 0xab, 0x32, 0xab, 0x2a,
+ ],
+ [
+ 0x40, 0x27, 0x64, 0xe5, 0x34, 0xd5, 0x7e, 0xd4, 0xe3, 0xba, 0x87, 0x26, 0x48,
+ 0xef, 0x87, 0xde, 0xd9, 0xe4, 0xa7, 0x16, 0xcb, 0x1e, 0x2d, 0x76, 0x46, 0xcb,
+ 0xc6, 0xb1, 0xab, 0x7d, 0xd6, 0xd2, 0x48, 0x62, 0x3d, 0x4b, 0xf4, 0x8d, 0xee,
+ 0xbd, 0xdb, 0xe3, 0xa3, 0x0f, 0xc5, 0x48, 0x01, 0xea,
+ ],
+ [
+ 0xf7, 0xb7, 0x76, 0xdd, 0x38, 0xb8, 0x62, 0x76, 0x7b, 0xca, 0x79, 0x71, 0x68,
+ 0x73, 0x0f, 0xf6, 0x47, 0x36, 0xce, 0x1c, 0x74, 0x95, 0xb5, 0x02, 0x10, 0x3b,
+ 0x85, 0x44, 0x75, 0x5e, 0x85, 0xb1, 0x19, 0xa6, 0x57, 0x47, 0x41, 0xb0, 0x27,
+ 0x24, 0x25, 0xd9, 0xc7, 0x3d, 0xa9, 0x22, 0xe4, 0x9d, 0xe2, 0x41, 0xfc, 0xe4,
+ 0x56, 0x2f, 0x69, 0x9d, 0x15, 0x5b, 0xa8, 0x93, 0xc0, 0x37, 0x36, 0x05,
+ ]
+ ),
+ test_case!(
+ [
+ 0x7a, 0x57, 0xb6, 0x71, 0xf8, 0x69, 0x57, 0xf7, 0xd3, 0x80, 0xf5, 0x54, 0xd0,
+ 0xdd, 0x97, 0xad, 0xd6, 0x58, 0x5d, 0xa2, 0x0e, 0x9c, 0xc5, 0xee, 0x07, 0xc4,
+ 0x79, 0x1d, 0x92, 0xcc, 0xb2, 0xa5, 0x10, 0x37, 0x4c, 0xce, 0x44, 0xd7, 0xbf,
+ 0xbf, 0x1d, 0x26, 0x66, 0xca, 0x6c, 0x44, 0x95, 0x98, 0x09, 0x4c, 0xd6, 0x41,
+ 0x14, 0xd6, 0xfa, 0x45, 0xb8, 0x39, 0x95, 0x9e, 0x83, 0xc5, 0xc3, 0x90, 0x4a,
+ 0xb3, 0x2c, 0x24, 0xfb, 0xe3, 0x40, 0xa7, 0xfa, 0xeb, 0x2d, 0xc6, 0xc0, 0xad,
+ 0x74, 0x8e, 0x48, 0x59, 0xa7, 0x64, 0x73, 0xf7, 0x2b, 0xd2, 0xb4, 0xa9, 0x83,
+ 0x9a, 0x69, 0x0a, 0xc9, 0x01, 0xab, 0x9b, 0x85, 0xf0, 0xa4,
+ ],
+ [
+ 0x6f, 0x4b, 0x03, 0x8b, 0xd7, 0x18, 0x83, 0x41, 0xa5, 0x00, 0xc6, 0x6b, 0x83,
+ 0xcb, 0xdb, 0x32, 0x76, 0x70, 0xf3, 0xf1,
+ ],
+ [
+ 0xf1, 0x4c, 0x09, 0xf7, 0xdf, 0x3e, 0x1d, 0x51, 0xdb, 0x5b, 0x25, 0xc9, 0xcc,
+ 0xbf, 0xff, 0xb8, 0xb5, 0x38, 0xb1, 0x1b, 0x4b, 0x1f, 0x01, 0xbf, 0x32, 0xe1,
+ 0x54, 0x2a, 0x6e, 0xdc, 0xb0, 0x8b,
+ ],
+ [
+ 0x61, 0xda, 0xcd, 0xbd, 0x28, 0x18, 0xc5, 0x48, 0x6d, 0xbc, 0xb1, 0xc7, 0xde,
+ 0x54, 0x45, 0x92, 0x81, 0xea, 0x3d, 0x49, 0xaa, 0x06, 0xda, 0xa1, 0x9a, 0x49,
+ 0xdc, 0xd9, 0xe7, 0x58, 0x89, 0xe2, 0xf9, 0xec, 0xb9, 0xe9, 0xc0, 0x6b, 0x48,
+ 0xd0, 0x03, 0x33, 0x93, 0x4d, 0x1c, 0xe9, 0xf6, 0x3a,
+ ],
+ [
+ 0x34, 0x81, 0xd0, 0xba, 0x19, 0xc4, 0xdf, 0xa6, 0x4d, 0x78, 0x64, 0xf3, 0x64,
+ 0xc6, 0xfd, 0x4a, 0x03, 0xc1, 0x01, 0xb9, 0x58, 0xf7, 0x7b, 0xb9, 0x3d, 0x05,
+ 0x3d, 0xf9, 0xf6, 0xba, 0xb0, 0x39, 0x48, 0x55, 0x48, 0x6b, 0x54, 0x02, 0x1a,
+ 0xbc, 0xe9, 0xec, 0xf5, 0xea, 0x2d, 0x99, 0x6a, 0x98, 0x79, 0x33, 0xf5, 0x31,
+ 0x3d, 0xef, 0x59, 0x54, 0x0a, 0x95, 0xb6, 0x71, 0x71, 0x3f, 0x29, 0x27,
+ ]
+ ),
+ test_case!(
+ [
+ 0x41, 0xf5, 0x30, 0xf0, 0x2e, 0x95, 0x87, 0x70, 0x03, 0x97, 0xd1, 0xe2, 0x04,
+ 0xa4, 0x00, 0x08, 0x17, 0xeb, 0x68, 0x3e, 0xd0, 0x64, 0xca, 0x79, 0x9d, 0x0b,
+ 0x67, 0xbc, 0xb0, 0x79, 0xcd, 0xca, 0x78, 0x50, 0x30, 0x46, 0xb7, 0x02, 0xaf,
+ 0x3f, 0x3c, 0x9f, 0xe2, 0xde, 0xcb, 0x9b, 0xd7, 0x96, 0xc1, 0xfd, 0xf4, 0xca,
+ 0x9a, 0x2a, 0x85, 0x28, 0xf0, 0x8f, 0xe1, 0x59, 0xab, 0xdc, 0xa8, 0x6b, 0xb5,
+ 0x3d, 0x02, 0x8a, 0xd9, 0xa3, 0x91, 0x1b, 0xd0, 0xaa, 0x48, 0x5e, 0xb3, 0x04,
+ 0xb4, 0x2c, 0x36, 0xac, 0x0d, 0x2c, 0x5c, 0x12, 0x20, 0xf5, 0x4c, 0x3c, 0x91,
+ 0x87, 0x84, 0xad, 0x95, 0x65, 0x64, 0x7d, 0xb3, 0xba, 0x82, 0x88,
+ ],
+ [
+ 0x34, 0xbb, 0x67, 0x6a, 0x86, 0x7d, 0xa8, 0x56, 0x11, 0x84, 0xf3, 0x04, 0x5e,
+ 0xf8, 0x1d, 0x33, 0x83, 0x54, 0xa4, 0xcd,
+ ],
+ [
+ 0xaf, 0x69, 0xe7, 0x98, 0xd4, 0x88, 0x89, 0x44, 0x9c, 0x6a, 0xc7, 0xc9, 0xfc,
+ 0x1b, 0xcd, 0x47, 0x52, 0x39, 0x82, 0xd2, 0xa2, 0xe2, 0x9b, 0x98, 0x40, 0x88,
+ 0x7b, 0xd1, 0x26, 0x1a, 0x5a, 0xdb,
+ ],
+ [
+ 0xe8, 0x02, 0xb8, 0x18, 0x37, 0x7c, 0x75, 0xbb, 0xb6, 0xb2, 0x56, 0x12, 0x28,
+ 0x39, 0xa5, 0x00, 0xc9, 0xdc, 0x0a, 0x62, 0x3c, 0xed, 0xac, 0x97, 0x04, 0x50,
+ 0x9c, 0x34, 0xfe, 0x4e, 0x40, 0x52, 0xcc, 0x7c, 0x65, 0x38, 0x3e, 0x01, 0x0b,
+ 0x2e, 0x48, 0xb5, 0x35, 0xc6, 0x54, 0x65, 0x43, 0xe7,
+ ],
+ [
+ 0x6f, 0x52, 0xd8, 0x18, 0xd1, 0xf4, 0x88, 0x3d, 0xaf, 0x8c, 0xc4, 0xcd, 0x4e,
+ 0xe4, 0xb3, 0x29, 0x0d, 0x27, 0x06, 0x45, 0xdc, 0xbb, 0x2c, 0x5d, 0x3b, 0xd7,
+ 0xdb, 0xc9, 0xd9, 0xb4, 0x5a, 0xbe, 0x43, 0x05, 0xc6, 0x60, 0xaa, 0x69, 0x45,
+ 0x59, 0xf2, 0x39, 0xeb, 0x68, 0x05, 0x51, 0xba, 0x5e, 0x57, 0xd7, 0x95, 0x5e,
+ 0xec, 0x12, 0x75, 0x0e, 0x70, 0xe9, 0x03, 0xe9, 0x0b, 0xb7, 0x4c, 0x71,
+ ]
+ ),
+ test_case!(
+ [
+ 0x63, 0xd8, 0x56, 0x2a, 0x0b, 0x46, 0x3f, 0xda, 0x47, 0x27, 0xa0, 0x91, 0xed,
+ 0x90, 0x02, 0x64, 0xd6, 0x8f, 0x0a, 0x37, 0x98, 0xa8, 0x7d, 0x24, 0xba, 0x53,
+ 0x8f, 0xdb, 0x7c, 0xb0, 0x9a, 0x37, 0x45, 0xe5, 0x87, 0xac, 0x67, 0xc9, 0x44,
+ 0xd7, 0x47, 0xb0, 0x0c, 0x67, 0x86, 0xe5, 0x3b, 0x61, 0x04, 0x2f, 0x24, 0x89,
+ 0x3b, 0xf8, 0xb6, 0x3c, 0x3b, 0xde, 0xcd, 0xec, 0x95, 0x6d, 0x6c, 0xbd, 0x24,
+ 0x39, 0x24, 0xbc, 0x0f, 0x28, 0xdb, 0x1c, 0x0a, 0x4b, 0x40, 0x08, 0x55, 0x1c,
+ 0xd0, 0x84, 0xcc, 0x4a, 0xaa, 0x1f, 0xaa, 0x73, 0x4a, 0xc9, 0x0b, 0x57, 0x2b,
+ 0x6a, 0xc7, 0x22, 0xd2, 0xf3, 0x87, 0x4a, 0xfe, 0xe4, 0x0b, 0x15, 0xdb,
+ ],
+ [
+ 0x9d, 0x37, 0xab, 0x6a, 0x60, 0xcd, 0xa6, 0x80, 0x14, 0x29, 0x09, 0x23, 0xf9,
+ 0x78, 0xe5, 0xf3, 0x01, 0x22, 0xab, 0x0b,
+ ],
+ [
+ 0x3b, 0xd1, 0xa9, 0xb1, 0xf3, 0x83, 0x1f, 0x5d, 0xfe, 0x45, 0x09, 0x17, 0xce,
+ 0x3f, 0x90, 0x9a, 0xaa, 0xa2, 0xa7, 0xc0, 0xd7, 0x7b, 0x2c, 0x29, 0x65, 0xe1,
+ 0xa5, 0x15, 0xfc, 0xf5, 0x2f, 0x4c,
+ ],
+ [
+ 0xcc, 0x84, 0x9d, 0x11, 0xbe, 0xc3, 0x6a, 0xf1, 0xfb, 0xb8, 0x3b, 0x85, 0x7c,
+ 0x5b, 0xcc, 0xf1, 0xa6, 0x77, 0xf5, 0x96, 0xc0, 0xcc, 0xf8, 0x4e, 0x3e, 0xaa,
+ 0x17, 0x0b, 0xfb, 0x0b, 0xa2, 0xb1, 0xdc, 0xe6, 0xd5, 0xd1, 0x2b, 0x09, 0x3c,
+ 0x75, 0x80, 0x60, 0x31, 0x8b, 0x51, 0x70, 0x0e, 0xe1,
+ ],
+ [
+ 0x25, 0x74, 0xa7, 0x93, 0x86, 0x18, 0x74, 0x86, 0xec, 0x04, 0x75, 0xfb, 0xe3,
+ 0xbe, 0x36, 0xb2, 0x33, 0xd5, 0x51, 0x31, 0x38, 0x3b, 0x5e, 0xef, 0xb0, 0x23,
+ 0x50, 0x91, 0xbe, 0xd1, 0x5b, 0x17, 0xc8, 0xf5, 0xe6, 0xcd, 0xce, 0x2c, 0x6e,
+ 0x7b, 0x2c, 0xb7, 0x09, 0x48, 0xd1, 0x70, 0xfd, 0xd1, 0xe0, 0x6d, 0x5e, 0xa9,
+ 0xba, 0x31, 0x61, 0xbe, 0xc3, 0x79, 0x08, 0x37, 0x44, 0x49, 0x0b, 0xf5,
+ ]
+ ),
+ test_case!(
+ [
+ 0x0e, 0x5f, 0xac, 0x86, 0x14, 0xb6, 0xf5, 0x04, 0xde, 0x28, 0x18, 0x4f, 0x57,
+ 0xfc, 0x6e, 0xfa, 0x8d, 0x00, 0x2d, 0xb3, 0x30, 0x24, 0xc4, 0xdc, 0xb2, 0xc7,
+ 0x24, 0xa4, 0x4e, 0x08, 0x6e, 0xf5, 0xce, 0x88, 0x10, 0xef, 0xc2, 0x46, 0xbe,
+ 0x3b, 0x72, 0x31, 0xa2, 0x1b, 0xa8, 0x1e, 0xe3, 0x27, 0x9f, 0xe8, 0x34, 0x10,
+ 0xa6, 0xd8, 0x4a, 0xb8, 0x70, 0xfd, 0x65, 0x29, 0x60, 0xeb, 0x15, 0x53, 0xe2,
+ 0x24, 0xf5, 0x7e, 0xbc, 0xd7, 0x3d, 0x28, 0x9b, 0x81, 0x36, 0xe4, 0x83, 0x41,
+ 0x9f, 0x44, 0x3c, 0x7a, 0xe2, 0x62, 0x8f, 0xee, 0xf1, 0xa0, 0x5c, 0x13, 0x4d,
+ 0x43, 0x8b, 0x40, 0xd8, 0x9c, 0xf1, 0x1c, 0x74, 0x90, 0x25, 0x90, 0x68, 0xe3,
+ ],
+ [
+ 0x17, 0x36, 0x80, 0x59, 0xfe, 0x8b, 0xbb, 0x09, 0xff, 0x8d, 0x41, 0x3e, 0xee,
+ 0x65, 0xb2, 0x39, 0x6e, 0x84, 0x0a, 0x41,
+ ],
+ [
+ 0x2f, 0x7c, 0x45, 0x90, 0xa8, 0xbf, 0x38, 0xeb, 0xff, 0xaa, 0x49, 0xdb, 0xbd,
+ 0x9a, 0xdb, 0x3f, 0x7f, 0x11, 0x2a, 0xf5, 0x0f, 0xbb, 0x1e, 0x31, 0x07, 0x02,
+ 0xbf, 0x69, 0x98, 0xac, 0xbb, 0xc0,
+ ],
+ [
+ 0xb0, 0x5c, 0xad, 0x84, 0x0a, 0x9f, 0x33, 0x5b, 0x84, 0x39, 0x2a, 0xfe, 0x9d,
+ 0x4e, 0x20, 0xb8, 0x89, 0x83, 0x1b, 0x7e, 0xba, 0x24, 0x2b, 0x19, 0x08, 0x95,
+ 0x0b, 0x6c, 0x2e, 0xd3, 0x74, 0x51, 0xa4, 0xaf, 0xe1, 0x7d, 0xbe, 0x23, 0xcc,
+ 0x56, 0xdf, 0xe3, 0xfc, 0xf4, 0xcc, 0xc6, 0x59, 0x09,
+ ],
+ [
+ 0x14, 0xbd, 0xb7, 0x70, 0xc8, 0x3a, 0x3b, 0xb9, 0x7f, 0xaf, 0xe0, 0x17, 0x0a,
+ 0x6c, 0xdb, 0xdc, 0xf0, 0xb6, 0x68, 0x9f, 0xe9, 0xa4, 0xf7, 0x9e, 0x14, 0xef,
+ 0x9d, 0xda, 0xb7, 0xa0, 0x9a, 0xd8, 0x79, 0x4d, 0xd8, 0xbf, 0xed, 0x2d, 0x52,
+ 0xa2, 0xb4, 0x38, 0x68, 0x06, 0x9e, 0x41, 0x38, 0x3a, 0x4b, 0x2c, 0x30, 0x2d,
+ 0xee, 0xee, 0x03, 0x9e, 0xa9, 0x75, 0xec, 0xa3, 0x96, 0x1f, 0x07, 0x13,
+ ]
+ ),
+ test_case!(
+ [
+ 0x98, 0x9d, 0x34, 0x47, 0x65, 0xd1, 0xe7, 0xf4, 0xb5, 0x19, 0x7b, 0xb6, 0x44,
+ 0x55, 0x30, 0x8e, 0x83, 0xe0, 0x29, 0xba, 0x33, 0xc0, 0x50, 0xdf, 0xfd, 0x22,
+ 0xb2, 0xec, 0x5b, 0x46, 0x0f, 0x38, 0xf9, 0x23, 0x85, 0x66, 0xd9, 0xbd, 0x9f,
+ 0x83, 0xe3, 0x5a, 0x24, 0x1e, 0x7a, 0x72, 0xa8, 0x6c, 0x2b, 0xe9, 0xe1, 0xf6,
+ 0xec, 0xd1, 0xcf, 0x08, 0xce, 0xa1, 0xf7, 0x07, 0xd7, 0x38, 0xa5, 0x05, 0x86,
+ 0xc0, 0x09, 0xbe, 0x10, 0x0e, 0x6f, 0xca, 0xf0, 0x39, 0xaf, 0xaf, 0x95, 0x52,
+ 0xc8, 0x8b, 0xd9, 0x10, 0x7e, 0xdb, 0x32, 0xa4, 0xda, 0x8a, 0xef, 0xa3, 0xe0,
+ 0xc7, 0xe2, 0x07, 0x9f, 0x12, 0x09, 0xcc, 0x2d, 0x7a, 0xe2, 0xa9, 0x96, 0xf1,
+ 0xcd,
+ ],
+ [
+ 0xc2, 0x27, 0x51, 0xbc, 0x2c, 0x1a, 0x4c, 0x91, 0xe4, 0xcc, 0xf3, 0xaf, 0x37,
+ 0xd0, 0xbd, 0x4b, 0xee, 0xc5, 0xc0, 0x40,
+ ],
+ [
+ 0xd5, 0xfe, 0x72, 0x21, 0x4f, 0x27, 0x10, 0x17, 0x5b, 0x7a, 0xda, 0x27, 0x22,
+ 0xb7, 0x05, 0xd2, 0xdb, 0xab, 0xf2, 0xdd, 0x69, 0x26, 0x4d, 0xbb, 0x5f, 0xe6,
+ 0xa5, 0x50, 0xcc, 0x5a, 0x56, 0x43,
+ ],
+ [
+ 0x0f, 0x00, 0x36, 0xf2, 0x53, 0x6b, 0x7b, 0xff, 0xbc, 0xe4, 0x1a, 0x48, 0xd9,
+ 0x92, 0x89, 0xf0, 0x11, 0xb0, 0x43, 0x4b, 0x4a, 0xd5, 0x55, 0x8a, 0xd2, 0xd0,
+ 0x80, 0x4b, 0x41, 0x81, 0xc3, 0x35, 0xf0, 0x3c, 0xc1, 0xab, 0xc3, 0x87, 0xda,
+ 0xe2, 0x28, 0x22, 0xfb, 0x5d, 0x33, 0x32, 0x3b, 0x0c,
+ ],
+ [
+ 0x40, 0xcf, 0xe8, 0xc5, 0x02, 0xc4, 0x89, 0x08, 0xaf, 0x10, 0xec, 0x65, 0x88,
+ 0x12, 0xde, 0xee, 0x94, 0x3a, 0x45, 0x18, 0x7c, 0x83, 0xdd, 0x03, 0xe0, 0x99,
+ 0x44, 0x3f, 0x8c, 0xf5, 0xe6, 0x0c, 0x2f, 0x00, 0xc0, 0xbf, 0xb0, 0x9c, 0x36,
+ 0x96, 0x9e, 0x33, 0x2f, 0xae, 0x5f, 0x9d, 0x76, 0x0e, 0x03, 0x90, 0x31, 0x1c,
+ 0xca, 0x3b, 0x82, 0x8b, 0x6b, 0x4b, 0x58, 0x19, 0xc3, 0x6f, 0xd0, 0x3a,
+ ]
+ ),
+ test_case!(
+ [
+ 0xc6, 0x7e, 0x6d, 0xa1, 0x5a, 0x82, 0x7b, 0xbe, 0x2c, 0x40, 0x56, 0xfe, 0xf8,
+ 0x59, 0xcc, 0x95, 0x7a, 0xcc, 0x51, 0x6d, 0x93, 0xe9, 0xc3, 0x34, 0x60, 0x1d,
+ 0x2e, 0x60, 0x74, 0x97, 0x60, 0x36, 0x41, 0xd5, 0x62, 0x70, 0x61, 0xc4, 0x4d,
+ 0x3c, 0xea, 0xd5, 0x8a, 0x12, 0x2b, 0x3a, 0x8e, 0xab, 0xbd, 0xd1, 0x7c, 0x43,
+ 0xc4, 0x9b, 0x34, 0xb4, 0x9b, 0x0c, 0x4a, 0x8f, 0xd3, 0xa0, 0xcf, 0x8c, 0x60,
+ 0xf4, 0xde, 0xee, 0x15, 0xfd, 0xe9, 0x0c, 0xdd, 0x32, 0x4e, 0x6e, 0xb2, 0x77,
+ 0x83, 0xd8, 0x6a, 0x0b, 0x83, 0xa7, 0x68, 0x8f, 0x07, 0x35, 0xa8, 0x83, 0x65,
+ 0x92, 0x1f, 0x16, 0xc4, 0x63, 0xe0, 0xeb, 0xc9, 0x20, 0xa2, 0x95, 0xbc, 0x5a,
+ 0x28, 0x5f,
+ ],
+ [
+ 0xe0, 0xdb, 0x00, 0xfd, 0x72, 0x76, 0x2a, 0xfc, 0x34, 0x46, 0x6b, 0xd8, 0xaf,
+ 0x74, 0x1c, 0xa7, 0x59, 0xfc, 0x70, 0xd5,
+ ],
+ [
+ 0x80, 0xf0, 0xd5, 0x5c, 0x1a, 0x8f, 0x04, 0x21, 0x7c, 0x06, 0x8e, 0x3b, 0x55,
+ 0xaa, 0x52, 0xdb, 0x4a, 0x96, 0xde, 0xea, 0x68, 0x4d, 0x7f, 0xd0, 0x67, 0xc3,
+ 0xd1, 0xf4, 0x52, 0x02, 0x68, 0x25,
+ ],
+ [
+ 0x6e, 0x14, 0x19, 0xba, 0xf9, 0x81, 0x5f, 0x21, 0xf3, 0x9e, 0x57, 0x8c, 0xe1,
+ 0xb7, 0x39, 0x2f, 0xd6, 0xf2, 0xfe, 0xe1, 0xd5, 0x16, 0xc3, 0xc4, 0xb8, 0x69,
+ 0xae, 0x70, 0xf8, 0xb4, 0x63, 0x7b, 0xdb, 0x27, 0xc3, 0x4a, 0x80, 0xde, 0xa0,
+ 0xcb, 0x82, 0xa7, 0x1e, 0x87, 0xc0, 0xbe, 0x7f, 0xf3,
+ ],
+ [
+ 0xf0, 0x83, 0x7b, 0x73, 0x65, 0x95, 0x96, 0x4c, 0x95, 0xc1, 0xf5, 0x1e, 0x82,
+ 0xdf, 0xae, 0x41, 0xa5, 0x71, 0x26, 0x52, 0x95, 0x01, 0xbb, 0x3d, 0x45, 0x0c,
+ 0xae, 0xb6, 0x8a, 0xba, 0x6d, 0xeb, 0xad, 0x57, 0xf4, 0x31, 0x92, 0x3a, 0x4d,
+ 0xa3, 0x32, 0x45, 0xfe, 0x72, 0x05, 0x5a, 0xae, 0xa0, 0xd9, 0x3e, 0x18, 0x21,
+ 0x5b, 0x54, 0xe7, 0x48, 0xab, 0x9c, 0x87, 0xcd, 0xf2, 0x0a, 0x20, 0x8c,
+ ]
+ ),
+ test_case!(
+ [
+ 0xae, 0x49, 0x35, 0xad, 0xdc, 0xa1, 0x98, 0x8a, 0x06, 0x46, 0xf9, 0x75, 0xaa,
+ 0x8b, 0x96, 0xd3, 0xd1, 0x67, 0xea, 0x8e, 0x9a, 0xc6, 0xc4, 0xcb, 0xe0, 0xa8,
+ 0xa6, 0xa0, 0x1c, 0x34, 0x19, 0x29, 0xd5, 0x46, 0x0b, 0xd6, 0x36, 0x09, 0x3b,
+ 0xa7, 0xf3, 0xd1, 0x9d, 0x6f, 0x29, 0xbd, 0x63, 0xcd, 0xbc, 0xe8, 0x2a, 0x49,
+ 0x98, 0x1f, 0x38, 0xd6, 0xda, 0xb0, 0xdf, 0x5e, 0x33, 0x00, 0x08, 0xfd, 0x11,
+ 0xe1, 0x4d, 0xa0, 0x39, 0x78, 0xba, 0x83, 0x76, 0x60, 0xed, 0x7e, 0x1f, 0xa3,
+ 0xcf, 0x6b, 0xcb, 0x9c, 0x78, 0xf7, 0xb9, 0x9e, 0xb8, 0xd8, 0x33, 0xcb, 0x42,
+ 0x8d, 0x1f, 0x3a, 0x9f, 0xcc, 0x44, 0x6a, 0x7a, 0x1d, 0x73, 0x4c, 0xdc, 0xf6,
+ 0x05, 0x6b, 0xbc,
+ ],
+ [
+ 0x13, 0x40, 0x12, 0xcc, 0x6f, 0x06, 0x07, 0xa1, 0x64, 0x38, 0x57, 0xfb, 0xfe,
+ 0x05, 0x55, 0xf0, 0x84, 0xe3, 0x79, 0x0c,
+ ],
+ [
+ 0x5b, 0x7d, 0x4d, 0x7f, 0x3e, 0x7c, 0x02, 0xe6, 0xeb, 0x3a, 0x53, 0xc3, 0x1c,
+ 0x24, 0xcf, 0x5c, 0xc2, 0x69, 0x97, 0x29, 0x7e, 0x7a, 0x2e, 0x71, 0xc7, 0x4e,
+ 0xc0, 0x96, 0xf4, 0x9b, 0xda, 0x30,
+ ],
+ [
+ 0x0a, 0x5a, 0xcb, 0xc2, 0x72, 0x47, 0x41, 0xa4, 0xf7, 0xcb, 0x3d, 0x9a, 0x13,
+ 0x75, 0xa9, 0x37, 0xd6, 0xe3, 0x79, 0x1c, 0x24, 0x3f, 0xea, 0xb3, 0x0e, 0x3e,
+ 0xc0, 0xb2, 0xea, 0x67, 0xe5, 0xce, 0xf1, 0xd0, 0xf7, 0xa1, 0x5e, 0x32, 0x44,
+ 0x42, 0x97, 0xbb, 0xa8, 0x82, 0xaf, 0x42, 0x42, 0xd1,
+ ],
+ [
+ 0x75, 0xb5, 0x1e, 0x80, 0x80, 0x56, 0xd7, 0x67, 0x23, 0x63, 0xc8, 0x4e, 0x7a,
+ 0xfd, 0x13, 0x4e, 0x27, 0x90, 0xfb, 0xad, 0xcb, 0x49, 0x7d, 0x1c, 0x49, 0x0a,
+ 0x61, 0x2a, 0x80, 0xbc, 0x47, 0x60, 0x3b, 0x35, 0x0d, 0x76, 0xa2, 0x14, 0x50,
+ 0xbd, 0x22, 0x94, 0xc9, 0x63, 0xd5, 0x48, 0xa3, 0x2d, 0xb0, 0x13, 0x63, 0x49,
+ 0x02, 0xc8, 0x3d, 0x8d, 0x32, 0x5d, 0x8d, 0x13, 0x09, 0x01, 0x5d, 0x1c,
+ ]
+ ),
+ test_case!(
+ [
+ 0x08, 0x39, 0x24, 0xb6, 0x21, 0xd2, 0x2e, 0x80, 0x5f, 0xd2, 0x73, 0x84, 0x8e,
+ 0x71, 0x3b, 0x9f, 0x31, 0x8d, 0x10, 0x8a, 0x75, 0x41, 0xfa, 0x87, 0xbc, 0x6b,
+ 0xa1, 0x4c, 0x4d, 0xd9, 0xfb, 0xbe, 0xf3, 0x6f, 0x10, 0x4a, 0x91, 0xc7, 0x58,
+ 0x26, 0x57, 0x31, 0x52, 0x4f, 0x59, 0x49, 0xae, 0x47, 0xc0, 0xac, 0xb3, 0x99,
+ 0xfd, 0x52, 0x27, 0x41, 0xd6, 0xfa, 0x59, 0x1e, 0x1e, 0x45, 0xcc, 0x17, 0x5b,
+ 0x4e, 0x29, 0x54, 0xad, 0xb9, 0xf7, 0xa1, 0x6f, 0x8b, 0x94, 0x40, 0xbb, 0x12,
+ 0xd3, 0x3b, 0x32, 0x76, 0xc9, 0xa9, 0x99, 0x70, 0xda, 0xe8, 0x79, 0x7a, 0xee,
+ 0xe2, 0x3e, 0xb9, 0x4d, 0x43, 0xf0, 0x49, 0x1e, 0x02, 0x63, 0xec, 0xf5, 0x25,
+ 0xbb, 0x0f, 0x44, 0x26,
+ ],
+ [
+ 0x54, 0x8e, 0x7a, 0xf0, 0xf4, 0x89, 0x04, 0xbc, 0x96, 0xc4, 0x61, 0x0d, 0x38,
+ 0x5f, 0xfc, 0xf2, 0xe2, 0xf7, 0x01, 0x55,
+ ],
+ [
+ 0x85, 0x45, 0x01, 0x67, 0xf0, 0x68, 0x54, 0xaf, 0xfa, 0x20, 0x7a, 0x83, 0xe4,
+ 0xfb, 0xa2, 0x36, 0xe6, 0x06, 0x72, 0xa7, 0x0e, 0x9b, 0xcf, 0xa9, 0x66, 0x48,
+ 0xc6, 0x6f, 0x35, 0xb5, 0x93, 0x3d,
+ ],
+ [
+ 0x81, 0x90, 0xe3, 0x36, 0x41, 0xd8, 0xba, 0x97, 0x45, 0x49, 0xce, 0x9e, 0x76,
+ 0x11, 0xdc, 0x7e, 0x9d, 0x9d, 0x79, 0x31, 0xc7, 0xa2, 0x94, 0xba, 0x18, 0x75,
+ 0xfc, 0x7f, 0x68, 0x99, 0x49, 0x93, 0x87, 0xe8, 0x98, 0x94, 0xe2, 0x93, 0x93,
+ 0x6f, 0x1f, 0xa7, 0xfa, 0x06, 0x45, 0x61, 0x9d, 0x08,
+ ],
+ [
+ 0x8e, 0x70, 0x56, 0x7e, 0x99, 0x0a, 0x3d, 0xcc, 0x62, 0x5a, 0x22, 0x4c, 0x7c,
+ 0x4f, 0x41, 0xf2, 0xef, 0x4e, 0xbc, 0x7f, 0x4d, 0xe1, 0x75, 0xaf, 0xf6, 0x2e,
+ 0xe3, 0x22, 0x40, 0x3d, 0x04, 0xe8, 0xff, 0xf9, 0x89, 0x5c, 0xa7, 0xdf, 0x90,
+ 0xcc, 0x1b, 0x44, 0x4a, 0x61, 0xe6, 0x25, 0x28, 0x43, 0x41, 0xfb, 0x95, 0x60,
+ 0xb7, 0x42, 0x71, 0x9b, 0x3d, 0x76, 0x6e, 0x05, 0x9a, 0xdc, 0x32, 0x95,
+ ]
+ ),
+ test_case!(
+ [
+ 0xb5, 0x14, 0x6d, 0x49, 0x4c, 0xa9, 0x01, 0xfc, 0x77, 0x8f, 0x03, 0x8e, 0x97,
+ 0x88, 0x9c, 0x42, 0x8e, 0x9e, 0x4a, 0x69, 0x04, 0x83, 0x6f, 0x04, 0x43, 0xd7,
+ 0x1b, 0x26, 0x68, 0xed, 0xef, 0x3d, 0x59, 0x1a, 0xbd, 0x32, 0x05, 0x3f, 0x66,
+ 0x94, 0x4c, 0x92, 0x31, 0x51, 0xcd, 0xa3, 0xaa, 0xde, 0xe9, 0xf2, 0x57, 0xf3,
+ 0xb4, 0x06, 0x0c, 0xf1, 0xc3, 0x4e, 0x11, 0x78, 0x21, 0x56, 0x30, 0xfb, 0xd1,
+ 0xc8, 0x59, 0x14, 0xfc, 0x49, 0xeb, 0xf0, 0xf7, 0x57, 0x8c, 0xb3, 0xae, 0x8f,
+ 0x5c, 0x77, 0xb0, 0x31, 0xe7, 0x44, 0x75, 0x37, 0x78, 0x59, 0x99, 0x80, 0x0b,
+ 0x9d, 0x65, 0x21, 0x2d, 0xc2, 0x08, 0x8c, 0x42, 0xf6, 0x47, 0x66, 0x2d, 0x3c,
+ 0xb9, 0x20, 0x0a, 0xdc, 0x58,
+ ],
+ [
+ 0x8c, 0x13, 0x3b, 0x86, 0x53, 0x53, 0x53, 0x8e, 0x8c, 0x14, 0x29, 0x75, 0xbf,
+ 0x4b, 0xb3, 0x9f, 0xa7, 0x47, 0xee, 0x43,
+ ],
+ [
+ 0xfc, 0x6b, 0x1c, 0x1d, 0x9b, 0x7f, 0xb5, 0x4b, 0xf0, 0x24, 0x6b, 0x5e, 0x08,
+ 0x1e, 0x8e, 0xe9, 0x7c, 0x0f, 0xc0, 0x9c, 0xfc, 0x5b, 0x64, 0x3e, 0xb7, 0x0b,
+ 0x17, 0x8b, 0xe4, 0xcb, 0x6e, 0x57,
+ ],
+ [
+ 0x41, 0xb7, 0x43, 0xa2, 0xe3, 0x7c, 0xee, 0x23, 0x5f, 0x7e, 0xbb, 0x99, 0x5d,
+ 0x20, 0xcd, 0x64, 0x1e, 0x58, 0x9d, 0x3d, 0x64, 0x8f, 0x1d, 0xaf, 0xc0, 0x8e,
+ 0xa7, 0x1b, 0x9d, 0x46, 0x39, 0x51, 0x4b, 0xf6, 0xf5, 0x36, 0xa7, 0x27, 0x69,
+ 0x34, 0xc6, 0x33, 0x2a, 0x76, 0xdd, 0x1c, 0xe9, 0x86,
+ ],
+ [
+ 0x61, 0x6b, 0xdd, 0xe7, 0x6b, 0x81, 0xa1, 0x1f, 0x23, 0xd2, 0xe8, 0x86, 0xe9,
+ 0x84, 0x6b, 0x17, 0x11, 0x64, 0x54, 0x54, 0x1a, 0x75, 0xb8, 0xf5, 0xc0, 0xa5,
+ 0x57, 0x46, 0x87, 0x80, 0x2c, 0xcf, 0xda, 0x37, 0xff, 0xea, 0xde, 0xbb, 0xac,
+ 0x3b, 0xb6, 0x26, 0xd4, 0xf3, 0x40, 0x11, 0x86, 0xea, 0xe6, 0x8c, 0x79, 0xeb,
+ 0x50, 0x5b, 0xa2, 0x76, 0x79, 0xb4, 0x3e, 0x55, 0x6d, 0x3a, 0xcd, 0xcf,
+ ]
+ ),
+ test_case!(
+ [
+ 0xf1, 0xea, 0x8d, 0x82, 0x6d, 0x9b, 0xe3, 0xd7, 0x78, 0x2c, 0x7d, 0x5b, 0xca,
+ 0x2d, 0x4a, 0x63, 0x44, 0x8c, 0xa2, 0x1b, 0xf6, 0x3c, 0xb7, 0x0e, 0x3c, 0x35,
+ 0x92, 0x9a, 0x16, 0xe3, 0xd3, 0x47, 0x9a, 0xc8, 0xcd, 0x98, 0x6d, 0x7b, 0x9d,
+ 0xaf, 0xb5, 0x01, 0x91, 0x18, 0x70, 0x58, 0x1d, 0xba, 0x9f, 0x80, 0xdf, 0x3c,
+ 0x92, 0xc1, 0x4d, 0x66, 0x0a, 0xec, 0x73, 0x00, 0xdb, 0x2c, 0x8d, 0x0d, 0x7e,
+ 0xe1, 0x8a, 0x90, 0x7a, 0x20, 0xf2, 0xe6, 0xbf, 0x00, 0x08, 0xbd, 0xee, 0x92,
+ 0x95, 0xa9, 0x3c, 0xdb, 0x11, 0x01, 0x8f, 0x92, 0x8d, 0xc2, 0xdb, 0x9f, 0xe1,
+ 0x81, 0xb6, 0x4f, 0x73, 0xdd, 0x67, 0x3e, 0x8d, 0x0b, 0xb9, 0x32, 0xfd, 0x47,
+ 0xab, 0x0d, 0xdf, 0x9b, 0xcb, 0x1d,
+ ],
+ [
+ 0x41, 0x7b, 0xa5, 0xc8, 0x71, 0xe8, 0x44, 0x75, 0xe4, 0x26, 0x7e, 0x08, 0x6f,
+ 0x2e, 0x4e, 0xe5, 0xc8, 0x53, 0xcc, 0x8e,
+ ],
+ [
+ 0x3e, 0x14, 0x86, 0xd7, 0x1e, 0x1d, 0xf3, 0xd6, 0x94, 0x28, 0xf9, 0x7a, 0x31,
+ 0xf4, 0x3a, 0x61, 0x08, 0x5b, 0x39, 0xc1, 0x6d, 0xf4, 0x24, 0x94, 0xd5, 0x4d,
+ 0x99, 0x42, 0xad, 0x5b, 0xd3, 0x92,
+ ],
+ [
+ 0x4f, 0x96, 0xad, 0xe7, 0x50, 0x21, 0x99, 0xbd, 0xba, 0xe4, 0x03, 0xd3, 0x28,
+ 0x53, 0x0c, 0x38, 0xd4, 0xca, 0x4f, 0x03, 0x8d, 0xea, 0x0d, 0x38, 0x93, 0xbd,
+ 0xe7, 0x2e, 0xbd, 0xc3, 0xaa, 0xab, 0x1b, 0xb8, 0xe6, 0xd4, 0x8a, 0x93, 0x2a,
+ 0x39, 0x8e, 0x3d, 0x96, 0x8c, 0xab, 0x00, 0x2d, 0x0c,
+ ],
+ [
+ 0x40, 0x9a, 0x8a, 0x20, 0xd8, 0x6d, 0x0b, 0x2f, 0x82, 0x90, 0x50, 0xd1, 0x8a,
+ 0x1d, 0xb3, 0x80, 0x25, 0x5a, 0xbd, 0xf4, 0xc7, 0x0d, 0xb3, 0xa0, 0x8e, 0xfc,
+ 0xde, 0x96, 0x40, 0x27, 0xd4, 0x64, 0x79, 0x60, 0x98, 0xd0, 0xcb, 0xf5, 0x53,
+ 0x7b, 0xdf, 0x2d, 0x32, 0xdf, 0x7c, 0x5b, 0x09, 0xec, 0x7f, 0x7a, 0x08, 0x41,
+ 0x1c, 0x4e, 0x3b, 0x2d, 0x59, 0x67, 0xc3, 0x25, 0xce, 0x5e, 0x91, 0x45,
+ ]
+ ),
+ test_case!(
+ [
+ 0xa4, 0x18, 0x9d, 0xfd, 0x9a, 0x35, 0x34, 0xe4, 0x73, 0x63, 0x36, 0xd3, 0xf3,
+ 0x95, 0x7f, 0x49, 0x2b, 0x8f, 0x02, 0xa0, 0x5d, 0xa5, 0x10, 0xd1, 0x56, 0x4e,
+ 0xb0, 0xa6, 0x99, 0xb1, 0xf5, 0x4d, 0x30, 0xab, 0x82, 0xf1, 0x48, 0xbf, 0x6f,
+ 0x01, 0x42, 0x3c, 0x1e, 0xba, 0xad, 0xc5, 0x66, 0x9a, 0xe4, 0xe1, 0x60, 0xd1,
+ 0x56, 0x7f, 0x2f, 0x16, 0xdf, 0xe7, 0x5e, 0x52, 0xee, 0xe6, 0x59, 0x2b, 0x99,
+ 0x41, 0x29, 0xa8, 0xa1, 0x4c, 0xe7, 0x97, 0x07, 0x22, 0x30, 0x34, 0x07, 0x82,
+ 0x0d, 0x20, 0xb9, 0xcb, 0xa0, 0x39, 0xaa, 0x38, 0x00, 0xf9, 0xcf, 0x02, 0xe8,
+ 0xc3, 0x4b, 0xb6, 0xee, 0x62, 0x54, 0x6c, 0xbd, 0x08, 0xe8, 0xab, 0xe3, 0x51,
+ 0x09, 0x32, 0x1b, 0xe7, 0xe8, 0x37, 0x7c,
+ ],
+ [
+ 0x2b, 0x2f, 0x47, 0x4c, 0x74, 0xe9, 0x54, 0x25, 0xa4, 0x02, 0xd4, 0xf3, 0xa4,
+ 0xba, 0x04, 0x4e, 0x6d, 0x4d, 0x8b, 0xf1,
+ ],
+ [
+ 0xd4, 0xb2, 0xa8, 0x5d, 0xff, 0x21, 0xc8, 0x17, 0xeb, 0x40, 0xb2, 0xd6, 0x3f,
+ 0xbd, 0x3a, 0xf2, 0x42, 0xb1, 0x13, 0x04, 0x05, 0x94, 0xf8, 0x5c, 0xce, 0x69,
+ 0x82, 0x5c, 0x98, 0x54, 0xb6, 0x0d,
+ ],
+ [
+ 0x6e, 0xad, 0xbc, 0x38, 0x81, 0xa6, 0x3f, 0x8e, 0xed, 0xe1, 0x71, 0x72, 0xc1,
+ 0x79, 0xd8, 0xa9, 0xf9, 0x4e, 0x9d, 0x0a, 0x48, 0x1d, 0x55, 0xfc, 0xbd, 0xc2,
+ 0xdf, 0x71, 0xd0, 0x9b, 0x19, 0x06, 0xf0, 0xf5, 0x07, 0x4f, 0x12, 0x5b, 0x45,
+ 0xd5, 0x45, 0xa2, 0xdf, 0x0c, 0x15, 0xd4, 0x03, 0xa0,
+ ],
+ [
+ 0xaa, 0x0d, 0x5e, 0x4c, 0xc6, 0x9e, 0x85, 0x47, 0x30, 0x67, 0xdb, 0x63, 0xe9,
+ 0xed, 0x74, 0x6e, 0x11, 0x33, 0x02, 0xf1, 0xd0, 0xa8, 0x9f, 0xb9, 0x81, 0x49,
+ 0x88, 0x2b, 0x37, 0x04, 0x2a, 0x53, 0xd7, 0x1d, 0x2f, 0x9f, 0xdc, 0xe0, 0x00,
+ 0x8f, 0x0c, 0xe5, 0x74, 0x1e, 0x48, 0x73, 0x4f, 0x14, 0x07, 0x93, 0x3e, 0x24,
+ 0xed, 0xea, 0x58, 0x7a, 0x72, 0xbb, 0xce, 0x99, 0xb6, 0x85, 0xa8, 0x04,
+ ]
+ ),
+ test_case!(
+ [
+ 0xe1, 0x66, 0x54, 0x9d, 0x89, 0xba, 0x1a, 0x92, 0x89, 0x90, 0x82, 0xac, 0x46,
+ 0x27, 0xb2, 0xb3, 0x04, 0x5d, 0x9a, 0xef, 0x4e, 0x0c, 0xe2, 0x7a, 0xe8, 0xdd,
+ 0xda, 0xb7, 0x16, 0x87, 0x58, 0xf7, 0x25, 0xcb, 0x23, 0xfc, 0x59, 0x23, 0x4f,
+ 0x8f, 0x40, 0x44, 0x75, 0xff, 0x7a, 0xcd, 0x6c, 0x41, 0x74, 0x39, 0x00, 0xad,
+ 0xca, 0x50, 0xff, 0x91, 0x77, 0x16, 0xe5, 0x05, 0x02, 0xc2, 0x21, 0x08, 0x81,
+ 0x50, 0x5d, 0x0a, 0xd7, 0x9b, 0x41, 0xe4, 0x48, 0x4e, 0x19, 0xd4, 0xe8, 0x6c,
+ 0xca, 0x99, 0xf3, 0x81, 0xc9, 0xa6, 0x0f, 0x62, 0x23, 0x53, 0x43, 0x35, 0x40,
+ 0x53, 0x34, 0xc6, 0xa2, 0xf2, 0x81, 0x54, 0xe2, 0xb5, 0x33, 0xf3, 0x18, 0x61,
+ 0x4d, 0x76, 0xe1, 0xe4, 0xa9, 0xaf, 0x86, 0xaf,
+ ],
+ [
+ 0x12, 0xf0, 0x89, 0x09, 0x46, 0xed, 0xac, 0x56, 0x44, 0x72, 0x73, 0x8e, 0xd2,
+ 0x7f, 0x22, 0x2e, 0x28, 0xbb, 0x8f, 0x67,
+ ],
+ [
+ 0xc8, 0x90, 0x61, 0xa1, 0x10, 0x1d, 0xaa, 0xed, 0x5d, 0x84, 0xaa, 0xe7, 0xbc,
+ 0x16, 0x4e, 0x75, 0xcf, 0x14, 0x4e, 0x65, 0x0c, 0x43, 0xc1, 0x7a, 0xc4, 0x47,
+ 0x40, 0x01, 0x51, 0x8a, 0x9d, 0x9c,
+ ],
+ [
+ 0x07, 0xfa, 0x94, 0x07, 0x67, 0xe9, 0x1f, 0xbd, 0x03, 0x21, 0x98, 0xe3, 0x55,
+ 0xaf, 0x8b, 0x17, 0xcd, 0xfe, 0xad, 0x99, 0x39, 0x67, 0x80, 0xb4, 0x52, 0xf6,
+ 0x4b, 0x71, 0x92, 0x8a, 0xc2, 0x90, 0x5c, 0x54, 0x9d, 0xcc, 0xee, 0xa1, 0x5e,
+ 0x88, 0xe7, 0x6e, 0xb9, 0x8e, 0xb5, 0xfd, 0x03, 0x86,
+ ],
+ [
+ 0x4d, 0x1e, 0x52, 0xd8, 0xdc, 0x7b, 0x67, 0x3f, 0xe4, 0xa1, 0x03, 0x79, 0xf1,
+ 0xfe, 0x76, 0xb0, 0xfc, 0x82, 0xe3, 0x75, 0x00, 0x2c, 0x85, 0x80, 0xf7, 0xa8,
+ 0x53, 0x32, 0x8f, 0xae, 0x3d, 0xeb, 0xd3, 0x7a, 0xd8, 0xa2, 0xe0, 0x1a, 0x4c,
+ 0x0a, 0x79, 0x6e, 0x7c, 0x06, 0x44, 0x0f, 0x87, 0x71, 0x38, 0x07, 0x61, 0x91,
+ 0x79, 0x34, 0xbb, 0x0e, 0xf2, 0x48, 0x45, 0x8f, 0x8c, 0xfb, 0x4a, 0x01,
+ ]
+ ),
+ test_case!(
+ [
+ 0x4a, 0x53, 0xae, 0x9f, 0xa6, 0x30, 0xa1, 0x42, 0x37, 0xb2, 0x8f, 0x03, 0xa6,
+ 0xfa, 0x1d, 0x67, 0x72, 0xda, 0xbd, 0xd1, 0xa9, 0x0f, 0xcc, 0x6c, 0xbd, 0x40,
+ 0xa9, 0xf3, 0x3b, 0x76, 0x6d, 0x4c, 0x1e, 0x91, 0x9c, 0x5b, 0x65, 0xf5, 0x43,
+ 0xcb, 0x07, 0x50, 0x90, 0x5c, 0x89, 0xb2, 0xcc, 0x25, 0xff, 0xf4, 0x20, 0xf2,
+ 0x7c, 0x81, 0x52, 0x49, 0x39, 0xf1, 0xc1, 0x66, 0x3d, 0xf8, 0xed, 0x07, 0xd8,
+ 0xf9, 0xb1, 0x9a, 0x50, 0x0e, 0x8a, 0xe9, 0xdc, 0x5b, 0xdd, 0xb4, 0xda, 0x74,
+ 0xb1, 0x8c, 0xf2, 0xf0, 0x2c, 0xb3, 0x6a, 0x78, 0x7a, 0x44, 0x1d, 0x2f, 0x7c,
+ 0xa4, 0x8b, 0x7b, 0x3e, 0xd6, 0x14, 0x6f, 0x36, 0xfe, 0xdc, 0x37, 0x00, 0xe4,
+ 0x3b, 0xb8, 0xbe, 0x0c, 0x7f, 0x05, 0xa3, 0x17, 0xb6,
+ ],
+ [
+ 0x9b, 0xa1, 0x42, 0x6a, 0xff, 0x8a, 0xad, 0xf4, 0x58, 0x32, 0xee, 0x84, 0x43,
+ 0x92, 0x5d, 0xc1, 0x67, 0x21, 0x73, 0x99,
+ ],
+ [
+ 0x09, 0xed, 0x65, 0x34, 0xf7, 0x07, 0xe8, 0xb0, 0x70, 0x84, 0xf2, 0x79, 0xee,
+ 0x4b, 0xf0, 0x96, 0x14, 0xa4, 0x43, 0xee, 0xdc, 0xd1, 0xbe, 0x5e, 0xe9, 0x27,
+ 0x50, 0x07, 0xb5, 0x0b, 0xeb, 0xa7,
+ ],
+ [
+ 0x5e, 0xff, 0x39, 0x41, 0x0c, 0xb0, 0xce, 0x63, 0x87, 0xe3, 0xb7, 0x2b, 0xe7,
+ 0xf1, 0xa2, 0x9e, 0xf8, 0x5f, 0xa4, 0x2e, 0xc8, 0x6b, 0x3a, 0x44, 0x69, 0xce,
+ 0xa6, 0x42, 0x94, 0x6e, 0x2b, 0x18, 0x2b, 0x6f, 0xdf, 0x9f, 0x2e, 0x5d, 0x71,
+ 0xf7, 0xf3, 0x3e, 0xb6, 0x7f, 0xce, 0x39, 0x95, 0x83,
+ ],
+ [
+ 0x6b, 0xc8, 0x6e, 0x6a, 0xac, 0xcc, 0x3a, 0x5f, 0xe8, 0x56, 0x92, 0x7b, 0x3a,
+ 0xf0, 0x51, 0x4c, 0xbc, 0x14, 0x3f, 0x1b, 0x1d, 0xd8, 0x05, 0x48, 0x9e, 0x00,
+ 0x21, 0xfa, 0xfb, 0x7f, 0xaa, 0xd2, 0x7c, 0xd8, 0x92, 0x22, 0x79, 0x08, 0x99,
+ 0xf9, 0xe4, 0x06, 0x05, 0x2e, 0x54, 0x62, 0xcc, 0x0d, 0x7c, 0xdf, 0x8c, 0x07,
+ 0x25, 0xca, 0x3d, 0x11, 0xa0, 0xec, 0x0e, 0x06, 0x23, 0x42, 0x97, 0xb8,
+ ]
+ ),
+ test_case!(
+ [
+ 0x76, 0xd7, 0x3d, 0x4f, 0x69, 0xdc, 0x8c, 0x5c, 0xf5, 0xb6, 0x67, 0x9c, 0x21,
+ 0x46, 0x5c, 0x96, 0x9a, 0xcf, 0x70, 0x93, 0xa7, 0x5e, 0xa9, 0x10, 0x6e, 0xaa,
+ 0x97, 0xa7, 0xee, 0x4b, 0xaf, 0x22, 0xb8, 0xaf, 0x17, 0x53, 0xe6, 0xb9, 0x24,
+ 0x44, 0x74, 0xb0, 0x46, 0xc9, 0xd0, 0x4b, 0xdc, 0xa8, 0xb7, 0x0f, 0x40, 0xf1,
+ 0xac, 0xea, 0x50, 0xfe, 0x29, 0x5b, 0x3e, 0x5d, 0xc5, 0x03, 0x95, 0xc2, 0x7c,
+ 0x86, 0xe2, 0x5d, 0x6f, 0x96, 0x42, 0xae, 0x78, 0x59, 0xeb, 0xde, 0xb5, 0xa8,
+ 0x3b, 0x1c, 0xed, 0x22, 0x69, 0x20, 0xef, 0x40, 0x49, 0xff, 0xa0, 0x67, 0x99,
+ 0xf6, 0x8b, 0x5e, 0xb9, 0x03, 0x04, 0xcb, 0x6e, 0x7d, 0x73, 0x55, 0xd1, 0x11,
+ 0xe1, 0xed, 0xe7, 0xf7, 0xfc, 0xd3, 0xb2, 0x6b, 0xdc, 0x60,
+ ],
+ [
+ 0x48, 0xab, 0xed, 0x0a, 0x34, 0x1e, 0xdb, 0x52, 0x91, 0xad, 0xb4, 0xfd, 0x6e,
+ 0x8d, 0xf4, 0x56, 0x69, 0x20, 0x12, 0x2a,
+ ],
+ [
+ 0x74, 0x3d, 0x94, 0xca, 0x8b, 0xad, 0x40, 0x3d, 0x7f, 0x35, 0xaa, 0x18, 0xb2,
+ 0x38, 0xad, 0x2d, 0x99, 0x90, 0x82, 0xe7, 0x1a, 0x0f, 0x53, 0xe2, 0x3f, 0x59,
+ 0x21, 0xfa, 0x3b, 0x33, 0x37, 0x18,
+ ],
+ [
+ 0x89, 0xbf, 0x09, 0xe1, 0xac, 0xcc, 0xb8, 0x0e, 0xf9, 0x5d, 0x8b, 0x2f, 0x96,
+ 0x17, 0x11, 0x6c, 0x45, 0x83, 0xcb, 0x01, 0xfb, 0xcb, 0x0a, 0xb5, 0x17, 0xef,
+ 0xdf, 0x3f, 0x26, 0x2a, 0x07, 0xbb, 0x3e, 0x8b, 0xf3, 0x7a, 0x4f, 0x48, 0xe1,
+ 0x26, 0x34, 0x65, 0x0b, 0x6d, 0x8a, 0x5b, 0x6a, 0xed,
+ ],
+ [
+ 0x7b, 0x85, 0x82, 0xb1, 0x7d, 0xd2, 0x72, 0x1f, 0xc9, 0x05, 0xc7, 0xda, 0xd0,
+ 0x89, 0x97, 0xff, 0xe6, 0x28, 0xdc, 0xfe, 0x92, 0x7f, 0x12, 0xde, 0xef, 0x36,
+ 0x83, 0xc6, 0x10, 0x77, 0x39, 0xfb, 0xf3, 0x2a, 0xbd, 0x04, 0xed, 0x33, 0x7d,
+ 0xb1, 0x76, 0x3e, 0xc7, 0x93, 0x8e, 0x12, 0x0d, 0x66, 0xd9, 0x33, 0x76, 0xf7,
+ 0x90, 0xe3, 0x27, 0xa3, 0x21, 0xbc, 0xde, 0x93, 0x2f, 0x83, 0x73, 0xe0,
+ ]
+ ),
+ test_case!(
+ [
+ 0x42, 0xdc, 0x01, 0xc6, 0x21, 0x6f, 0x63, 0xc4, 0xd7, 0x90, 0xe0, 0xdc, 0x4a,
+ 0xf0, 0xe8, 0x01, 0x96, 0x97, 0x00, 0x8a, 0x8b, 0xd6, 0x6e, 0x45, 0x0b, 0x3c,
+ 0x09, 0xa5, 0x7f, 0xe8, 0x1e, 0xa7, 0x56, 0x2f, 0x0a, 0x56, 0x59, 0x0c, 0xe5,
+ 0x21, 0xb8, 0xe9, 0x18, 0x50, 0x03, 0xb6, 0xbf, 0x8c, 0x65, 0xc9, 0xd1, 0x95,
+ 0x81, 0x1e, 0xa4, 0xa8, 0x0e, 0xec, 0x86, 0x27, 0xe4, 0x55, 0xe9, 0xe8, 0x2f,
+ 0xf0, 0xfa, 0x95, 0xfc, 0xe8, 0x4a, 0x0d, 0x31, 0x0e, 0x7b, 0x8a, 0xda, 0xf2,
+ 0xd6, 0x24, 0x8a, 0x60, 0x2f, 0x5e, 0x42, 0x9b, 0x3d, 0xc2, 0x67, 0x6d, 0x6b,
+ 0x82, 0x1f, 0x9e, 0x2e, 0x8d, 0x89, 0xf6, 0xc3, 0xe9, 0x21, 0x66, 0x6d, 0xf1,
+ 0x8f, 0x88, 0x03, 0xbe, 0xfe, 0xa2, 0xdf, 0x5d, 0x5d, 0xd7, 0x4e,
+ ],
+ [
+ 0x87, 0xd1, 0x06, 0xff, 0x32, 0xef, 0x61, 0xfc, 0xbf, 0x4e, 0x1e, 0x03, 0xad,
+ 0xe0, 0x7a, 0x92, 0x66, 0x43, 0xeb, 0x70,
+ ],
+ [
+ 0x5a, 0xc0, 0x1f, 0x00, 0xf8, 0xf9, 0x0b, 0x30, 0x06, 0x10, 0xe0, 0xf8, 0xfb,
+ 0x4e, 0xae, 0x3e, 0xad, 0x3d, 0xd8, 0xaf, 0x65, 0xa4, 0xae, 0xe6, 0xd6, 0x6d,
+ 0x6c, 0xc9, 0x48, 0x12, 0xe6, 0x13,
+ ],
+ [
+ 0x7e, 0xf3, 0x75, 0xab, 0xc5, 0x4a, 0x89, 0xe0, 0x89, 0xb5, 0x02, 0x7a, 0xda,
+ 0x3c, 0xac, 0x91, 0x59, 0xe7, 0xb7, 0xcd, 0x24, 0xfd, 0x8a, 0x7c, 0xf0, 0x78,
+ 0xa3, 0xea, 0xfa, 0x49, 0x9d, 0x9d, 0x90, 0x13, 0x27, 0x5b, 0x26, 0x6e, 0x57,
+ 0xd7, 0x89, 0xe3, 0x4a, 0x05, 0xf0, 0xb7, 0xc6, 0x14,
+ ],
+ [
+ 0xb7, 0x57, 0x73, 0xe3, 0x87, 0xc1, 0x44, 0xe5, 0x59, 0xd4, 0xb6, 0x1a, 0x3c,
+ 0x21, 0x82, 0x0e, 0xd4, 0x76, 0xd1, 0x53, 0x3e, 0x12, 0xa7, 0x0c, 0x24, 0xd3,
+ 0xf6, 0x35, 0xee, 0xfe, 0x06, 0xcb, 0xb9, 0xea, 0x50, 0x89, 0x61, 0x69, 0x4a,
+ 0x34, 0x26, 0x6c, 0xec, 0x3a, 0x08, 0x8e, 0x5e, 0x21, 0xc9, 0x41, 0x31, 0x45,
+ 0x09, 0x04, 0xb1, 0x16, 0x44, 0x47, 0xa1, 0x83, 0x23, 0xae, 0x41, 0xe0,
+ ]
+ ),
+ test_case!(
+ [
+ 0xff, 0xfb, 0xcd, 0x72, 0x05, 0x36, 0xe0, 0xbf, 0x38, 0x8a, 0xeb, 0xe0, 0xb7,
+ 0x48, 0xeb, 0xc2, 0x51, 0xac, 0xd6, 0xd3, 0xe3, 0x10, 0xbe, 0x8e, 0x79, 0x95,
+ 0xd0, 0x36, 0x37, 0x94, 0xed, 0x56, 0x2e, 0x3a, 0x09, 0x0a, 0x52, 0x0d, 0xb5,
+ 0x03, 0xd2, 0xd5, 0xcb, 0xcf, 0x21, 0x32, 0x4c, 0x57, 0xed, 0x74, 0x15, 0x7f,
+ 0xd6, 0x84, 0x8f, 0xc5, 0x0f, 0x14, 0xb0, 0x49, 0xc8, 0x1d, 0xbf, 0x29, 0x9a,
+ 0xa5, 0x42, 0x32, 0x10, 0x0f, 0x39, 0x68, 0x0f, 0x5b, 0x06, 0xdc, 0x04, 0x09,
+ 0xbb, 0x22, 0x7d, 0xe6, 0x46, 0x8a, 0x6c, 0xfb, 0x1d, 0xe3, 0xd6, 0x14, 0x50,
+ 0xb6, 0x77, 0xc2, 0x0a, 0x09, 0xb2, 0x10, 0xe5, 0xf2, 0xe2, 0x3d, 0x1f, 0xe5,
+ 0x75, 0xbc, 0xa6, 0xaa, 0xa5, 0x27, 0xa6, 0x38, 0xae, 0xf2, 0x0d, 0x87,
+ ],
+ [
+ 0x6d, 0x88, 0x3b, 0x25, 0xb1, 0xa3, 0xf5, 0xcc, 0xae, 0xd8, 0xea, 0xa5, 0xd6,
+ 0xa6, 0xb3, 0x9d, 0xa4, 0xd8, 0x9a, 0xf0,
+ ],
+ [
+ 0x32, 0x02, 0xf4, 0xd0, 0xb4, 0x18, 0x76, 0x4b, 0x1f, 0x92, 0x7f, 0xcf, 0xcf,
+ 0x21, 0x08, 0x58, 0xaa, 0x13, 0xc6, 0x11, 0xd1, 0x5f, 0x47, 0x8f, 0xf1, 0x00,
+ 0x5c, 0xa3, 0x29, 0x60, 0x1d, 0x8c,
+ ],
+ [
+ 0xf2, 0x0e, 0xd9, 0x4c, 0xbe, 0x00, 0xa6, 0x3b, 0x11, 0x48, 0x08, 0xc2, 0x72,
+ 0xd7, 0xa7, 0x07, 0x2f, 0xbb, 0xf8, 0xcb, 0x14, 0x58, 0xa1, 0xc7, 0x62, 0x78,
+ 0x23, 0x06, 0x58, 0x84, 0xe9, 0x51, 0xd8, 0x9c, 0xf4, 0xc8, 0xad, 0xb1, 0xed,
+ 0x09, 0x81, 0xbb, 0x1b, 0x2b, 0xde, 0x5c, 0x8a, 0x49,
+ ],
+ [
+ 0xc7, 0x27, 0x9d, 0x89, 0x51, 0x15, 0xfc, 0x29, 0x9b, 0x2c, 0x78, 0x24, 0x22,
+ 0xdf, 0xe2, 0x8e, 0x23, 0x28, 0xd1, 0xd6, 0x29, 0x5b, 0x6f, 0x24, 0xcb, 0x2d,
+ 0xbb, 0xc5, 0xea, 0xbb, 0xce, 0xf7, 0x8d, 0xde, 0x95, 0xe4, 0x2c, 0x63, 0x69,
+ 0x88, 0x51, 0x2f, 0xe5, 0x19, 0x9e, 0xbf, 0xd2, 0x91, 0xab, 0x1e, 0x9a, 0x11,
+ 0xa3, 0x3e, 0xfe, 0x0d, 0x68, 0xf1, 0xc3, 0xb6, 0xe2, 0xd2, 0xcb, 0x26,
+ ]
+ ),
+ test_case!(
+ [
+ 0xda, 0x98, 0x3b, 0x70, 0x4a, 0x7d, 0x30, 0x39, 0x41, 0x43, 0xca, 0x08, 0x31,
+ 0xf0, 0xfe, 0x8d, 0x07, 0x26, 0x08, 0x78, 0x82, 0xa6, 0x73, 0x4a, 0xcc, 0x5e,
+ 0xa3, 0xc4, 0x77, 0xbb, 0xbf, 0x70, 0x6f, 0x36, 0x4a, 0x49, 0xac, 0xb4, 0xc0,
+ 0xc3, 0x28, 0xbd, 0x7f, 0xfd, 0xf6, 0x24, 0x7d, 0x81, 0x2e, 0xc4, 0xcb, 0x5b,
+ 0x95, 0xb6, 0x68, 0x70, 0xaf, 0x5e, 0x14, 0xf6, 0x2c, 0x3e, 0xda, 0xa6, 0x6f,
+ 0xc5, 0x6a, 0x53, 0xde, 0x32, 0x22, 0x88, 0xe6, 0x0d, 0x84, 0x22, 0x78, 0x41,
+ 0x42, 0x85, 0x43, 0xe0, 0x19, 0x1b, 0x05, 0xeb, 0x44, 0xc0, 0x19, 0xf5, 0xb6,
+ 0x36, 0xd2, 0xbb, 0x28, 0x9f, 0x24, 0x4b, 0x35, 0x4d, 0xfe, 0x1f, 0x18, 0x8c,
+ 0x55, 0x5f, 0x7b, 0x75, 0x94, 0xfa, 0x72, 0xd7, 0x1d, 0xc5, 0xd5, 0x0c, 0xf1,
+ ],
+ [
+ 0x6c, 0x39, 0xee, 0xef, 0xb9, 0xbc, 0x44, 0x19, 0x69, 0x90, 0x7a, 0xf8, 0xe2,
+ 0x99, 0x0f, 0xda, 0x64, 0x5f, 0xd5, 0x1e,
+ ],
+ [
+ 0x71, 0x1d, 0x8f, 0x4d, 0xbe, 0x0c, 0xf0, 0xa5, 0x9a, 0x1a, 0x15, 0xcc, 0x2d,
+ 0xa7, 0x78, 0xcf, 0xfc, 0xe1, 0xba, 0x0c, 0xc3, 0x9e, 0xf3, 0x32, 0xb9, 0xa3,
+ 0x85, 0x1c, 0x96, 0xd9, 0xe9, 0xb2,
+ ],
+ [
+ 0x8b, 0x68, 0x75, 0xa4, 0x97, 0x19, 0x9e, 0x08, 0x98, 0xe0, 0x43, 0x57, 0x25,
+ 0xcb, 0x8a, 0xef, 0xcb, 0x32, 0x1b, 0x11, 0x30, 0x5d, 0x4d, 0xb4, 0xfc, 0xf0,
+ 0xfe, 0xc5, 0xff, 0xe0, 0x6f, 0x45, 0x7e, 0x91, 0xaa, 0xb0, 0x57, 0x0c, 0x37,
+ 0xe5, 0xdd, 0x95, 0xc5, 0x25, 0x67, 0x96, 0x09, 0x3d,
+ ],
+ [
+ 0x76, 0xa7, 0x57, 0xe1, 0x06, 0x7e, 0x3e, 0xfe, 0x97, 0xd0, 0x72, 0x06, 0x6a,
+ 0xab, 0x5c, 0x70, 0xa1, 0x2e, 0xa6, 0x51, 0x2c, 0x17, 0x18, 0x07, 0xad, 0xae,
+ 0xd4, 0xda, 0x27, 0x64, 0x03, 0x5b, 0xa7, 0x9e, 0xeb, 0xaf, 0x85, 0xe2, 0x88,
+ 0x47, 0xef, 0xd7, 0x10, 0x26, 0x2a, 0x47, 0xe0, 0xb3, 0x61, 0xdc, 0xbe, 0xf5,
+ 0x9a, 0x76, 0xc2, 0x28, 0x72, 0x7f, 0x5d, 0x88, 0x07, 0x6e, 0xf7, 0x63,
+ ]
+ ),
+ test_case!(
+ [
+ 0x9d, 0xd4, 0x85, 0x38, 0x98, 0x21, 0xf8, 0x31, 0x9d, 0x8f, 0x41, 0x82, 0x9d,
+ 0x3b, 0xad, 0x47, 0x7e, 0x57, 0xd8, 0x88, 0x55, 0xff, 0xdf, 0x60, 0x25, 0xe4,
+ 0x97, 0xdf, 0x36, 0x71, 0x3f, 0x8c, 0xa2, 0x11, 0x45, 0x53, 0xf6, 0x01, 0xa0,
+ 0x18, 0xcd, 0x08, 0x34, 0xb4, 0xdc, 0x25, 0x68, 0xbe, 0x26, 0x2d, 0x6b, 0x74,
+ 0x11, 0x24, 0x26, 0x9c, 0x24, 0xbb, 0xa7, 0x0a, 0x88, 0xf3, 0x47, 0x5c, 0xfe,
+ 0x0b, 0xb8, 0x32, 0x6a, 0x64, 0x04, 0x0c, 0xa8, 0x18, 0xf9, 0x86, 0x0a, 0x14,
+ 0x15, 0x2b, 0x18, 0x6b, 0x19, 0x6b, 0xf7, 0xe6, 0x06, 0xff, 0xfc, 0xf8, 0xf2,
+ 0x59, 0xf6, 0x06, 0x1b, 0x69, 0x8d, 0xf0, 0xb4, 0x42, 0x96, 0x80, 0x3c, 0xad,
+ 0x30, 0x1c, 0xfd, 0x4c, 0x85, 0xe0, 0x97, 0xe7, 0xbc, 0x99, 0x52, 0x5b, 0x6a,
+ 0xc1,
+ ],
+ [
+ 0xae, 0x01, 0x87, 0x69, 0xd0, 0x5b, 0x04, 0xc4, 0x92, 0x37, 0x4d, 0x4d, 0xa8,
+ 0x5f, 0x99, 0x73, 0x64, 0xf9, 0x09, 0x2c,
+ ],
+ [
+ 0xa1, 0xd7, 0xf6, 0x13, 0x56, 0xb8, 0xae, 0xda, 0xbd, 0x85, 0x37, 0xe3, 0x29,
+ 0x0a, 0x97, 0x5f, 0x7c, 0x21, 0x4c, 0xf5, 0x1c, 0xba, 0xeb, 0x5a, 0x16, 0xde,
+ 0x10, 0x91, 0xc4, 0x5b, 0xad, 0xba,
+ ],
+ [
+ 0x61, 0x0c, 0xc7, 0x8a, 0xc5, 0xa9, 0x88, 0x51, 0x72, 0xf9, 0x00, 0xb2, 0x45,
+ 0xcf, 0xed, 0x09, 0x61, 0xf9, 0xb6, 0x3d, 0x50, 0xb9, 0xe4, 0xbe, 0x49, 0x47,
+ 0xeb, 0xc6, 0x71, 0xb6, 0xd9, 0xf6, 0x72, 0xf8, 0xf3, 0xc4, 0x30, 0x60, 0x38,
+ 0xff, 0x28, 0xdf, 0xb8, 0x74, 0x65, 0x79, 0xbd, 0xad,
+ ],
+ [
+ 0x51, 0xd5, 0xbd, 0x85, 0x91, 0x64, 0x55, 0xdb, 0x2e, 0x7f, 0xaa, 0xb2, 0xef,
+ 0xe7, 0xef, 0x03, 0x8b, 0x94, 0xf2, 0x1e, 0x05, 0x76, 0xe3, 0x4d, 0xbe, 0x59,
+ 0xcd, 0xce, 0xd2, 0xe1, 0xc2, 0xe3, 0xf6, 0xda, 0xea, 0xd1, 0x5f, 0x00, 0x13,
+ 0x6a, 0x46, 0x1e, 0xd7, 0xf3, 0x5e, 0xc6, 0x8c, 0xb7, 0x90, 0xc1, 0xbd, 0x79,
+ 0xcf, 0x5b, 0xa4, 0xc9, 0x5a, 0xa2, 0x5d, 0x82, 0xd0, 0x4b, 0xae, 0xac,
+ ]
+ ),
+ test_case!(
+ [
+ 0x4c, 0x09, 0x85, 0x45, 0x82, 0x76, 0xb4, 0xff, 0x7e, 0x31, 0x8c, 0xa9, 0xf0,
+ 0x80, 0xda, 0x0c, 0x7f, 0x83, 0xc5, 0x55, 0x61, 0x52, 0xbe, 0xdc, 0x75, 0x53,
+ 0x7c, 0x14, 0x25, 0xfd, 0xa7, 0x52, 0x49, 0xe3, 0xf4, 0x7f, 0xcf, 0x93, 0x6b,
+ 0xf9, 0xe0, 0x45, 0x0a, 0xbd, 0xeb, 0xf6, 0x88, 0x3e, 0x0f, 0x64, 0xea, 0xf2,
+ 0xe5, 0x73, 0x2d, 0x67, 0x09, 0x21, 0xa1, 0x8c, 0xdc, 0xf7, 0xe1, 0xfd, 0x5d,
+ 0xb3, 0x4b, 0xd5, 0x06, 0xfc, 0x65, 0x3d, 0x4f, 0xd6, 0xf0, 0x74, 0x77, 0xc6,
+ 0x11, 0xfd, 0x6a, 0x46, 0x05, 0x29, 0x69, 0x52, 0x89, 0x53, 0xf8, 0x3a, 0xcf,
+ 0xdc, 0xd5, 0x26, 0x10, 0xf7, 0xab, 0x17, 0x50, 0x6a, 0x96, 0x50, 0x45, 0xc2,
+ 0x2e, 0xf9, 0x1b, 0x3e, 0xdb, 0x85, 0x0a, 0x9e, 0xa1, 0xd4, 0x59, 0x84, 0x2b,
+ 0xc1, 0x40,
+ ],
+ [
+ 0xf1, 0xa9, 0x90, 0x89, 0xd5, 0x24, 0x2e, 0x1d, 0x7c, 0x91, 0x19, 0x5d, 0x5a,
+ 0x8b, 0x55, 0x74, 0xf3, 0xfe, 0xfe, 0x2f,
+ ],
+ [
+ 0xe7, 0xdb, 0xb4, 0xcc, 0x82, 0xb4, 0x60, 0xc2, 0xe5, 0x65, 0x87, 0x7f, 0x80,
+ 0xcf, 0x3a, 0xfc, 0xa0, 0xcb, 0x2a, 0xf9, 0xe4, 0xfa, 0x7b, 0x0f, 0x9d, 0x55,
+ 0x3a, 0x50, 0xfc, 0x2c, 0x0c, 0x6f,
+ ],
+ [
+ 0x52, 0xd4, 0xff, 0x43, 0x7e, 0xc9, 0x7e, 0x3f, 0xee, 0xbe, 0x46, 0x14, 0xe3,
+ 0xc3, 0xde, 0x1d, 0xa0, 0xe7, 0x7a, 0x56, 0x94, 0x8e, 0xb4, 0x20, 0xe9, 0xbe,
+ 0x88, 0xa4, 0x2b, 0xc1, 0xb5, 0x10, 0x17, 0xea, 0x72, 0x44, 0x98, 0xe7, 0x24,
+ 0xba, 0xb7, 0xf7, 0x49, 0xf9, 0xe2, 0x6d, 0x0f, 0xa8,
+ ],
+ [
+ 0x47, 0x18, 0x39, 0xb3, 0xf1, 0xf5, 0x8a, 0x2f, 0x17, 0x01, 0x21, 0x28, 0xdf,
+ 0xd2, 0xe1, 0x3f, 0x47, 0xea, 0xb5, 0xe5, 0x8d, 0xef, 0xe9, 0xcd, 0x1e, 0xab,
+ 0x84, 0xed, 0x90, 0xa1, 0xc4, 0x24, 0x85, 0x0b, 0xc7, 0x18, 0xe8, 0xe0, 0x73,
+ 0xcd, 0x71, 0x30, 0xfd, 0xdb, 0x47, 0xad, 0x39, 0x8f, 0xf4, 0x1b, 0xe3, 0xe3,
+ 0x22, 0x7e, 0x4e, 0x0b, 0x51, 0x5d, 0xdb, 0x4b, 0xd0, 0x01, 0x76, 0xbf,
+ ]
+ ),
+ test_case!(
+ [
+ 0x11, 0x82, 0xce, 0xe5, 0x78, 0xce, 0x8e, 0xc7, 0x8d, 0x79, 0xb7, 0xbe, 0x18,
+ 0xac, 0x02, 0x60, 0xce, 0x98, 0x4b, 0xa8, 0xa3, 0xe6, 0x83, 0xee, 0x1f, 0x11,
+ 0x1a, 0xb8, 0xba, 0x5f, 0x83, 0x5b, 0x55, 0x7b, 0x2b, 0xe4, 0x97, 0x50, 0x69,
+ 0xa1, 0x62, 0x40, 0xf8, 0x59, 0xce, 0x03, 0xb6, 0x4a, 0x2f, 0xe6, 0xba, 0x71,
+ 0x90, 0xad, 0xa0, 0x34, 0xe3, 0x65, 0xc5, 0x90, 0x5c, 0x35, 0xbd, 0x63, 0x71,
+ 0x4f, 0xc4, 0xf6, 0x1e, 0xa7, 0x8f, 0x16, 0x34, 0x8c, 0x3d, 0x89, 0x5c, 0x0a,
+ 0x03, 0x5a, 0x29, 0x18, 0x30, 0x24, 0x1a, 0xfd, 0x03, 0xf1, 0x40, 0x05, 0xdf,
+ 0x3b, 0xd8, 0xa7, 0xb4, 0xfb, 0x5b, 0xc2, 0xf0, 0x6f, 0x8c, 0x16, 0x39, 0x1a,
+ 0x0f, 0x8e, 0x90, 0xc4, 0x1f, 0xdb, 0x10, 0xdd, 0x58, 0xaf, 0x4c, 0x23, 0x2b,
+ 0x86, 0xc6, 0xa7,
+ ],
+ [
+ 0x8f, 0xd6, 0x1c, 0x8e, 0xf7, 0xf3, 0xa5, 0x72, 0xc6, 0x2e, 0x28, 0x12, 0x79,
+ 0x35, 0xaf, 0x4c, 0x22, 0xfb, 0xcf, 0x51,
+ ],
+ [
+ 0x36, 0xcc, 0xa0, 0x29, 0xd4, 0x41, 0xb4, 0x5a, 0xd5, 0x38, 0x10, 0xc8, 0x6c,
+ 0xce, 0x07, 0x45, 0x91, 0x91, 0x52, 0x2b, 0xf4, 0x0e, 0x14, 0xf2, 0x69, 0xad,
+ 0xf4, 0x4d, 0x8e, 0xa7, 0xf7, 0x3f,
+ ],
+ [
+ 0x83, 0x95, 0x5a, 0xe5, 0x4b, 0xa7, 0x52, 0x97, 0xb1, 0xa9, 0x34, 0x8d, 0xcf,
+ 0xd3, 0x56, 0x66, 0x6e, 0x95, 0xe9, 0x54, 0x97, 0xec, 0xa3, 0xd4, 0xed, 0xe4,
+ 0x30, 0x71, 0x49, 0x82, 0xa3, 0x77, 0x5b, 0xcd, 0xd8, 0x44, 0xaf, 0x98, 0x0b,
+ 0x34, 0x6e, 0x8a, 0x3f, 0xbe, 0x7c, 0xaf, 0x35, 0x82,
+ ],
+ [
+ 0x06, 0xb0, 0xb7, 0xb4, 0xe0, 0x84, 0xf9, 0xd5, 0x7c, 0xb8, 0x37, 0x8b, 0x56,
+ 0x3d, 0xcb, 0x6e, 0xc9, 0xc9, 0xa5, 0xf7, 0x8d, 0x30, 0xea, 0x23, 0x67, 0x7b,
+ 0x65, 0x3e, 0x07, 0xef, 0x64, 0xee, 0x7e, 0x95, 0x23, 0x78, 0xea, 0x34, 0x5b,
+ 0x86, 0xc2, 0x49, 0x88, 0x93, 0x30, 0xa4, 0xa7, 0xd0, 0x1c, 0x0e, 0x94, 0xd9,
+ 0x35, 0x57, 0x73, 0x82, 0xd1, 0x9b, 0x6f, 0x5e, 0xa8, 0xd3, 0x30, 0x22,
+ ]
+ ),
+ test_case!(
+ [
+ 0xf2, 0xb5, 0xe5, 0xe6, 0x7c, 0x23, 0x99, 0x48, 0xa0, 0x21, 0x8f, 0xbd, 0x4c,
+ 0xe4, 0xbb, 0x16, 0x6c, 0xa3, 0x9d, 0x84, 0xf7, 0x5c, 0x8b, 0x20, 0x15, 0x95,
+ 0xf4, 0x81, 0x4d, 0x7a, 0x09, 0xa2, 0xd1, 0xdb, 0xbf, 0x0e, 0x09, 0x46, 0xfa,
+ 0xfa, 0xed, 0x1f, 0x36, 0xe6, 0x0f, 0xc4, 0x3c, 0x8c, 0xb7, 0x0d, 0x95, 0xc9,
+ 0xd8, 0x05, 0x0a, 0x44, 0x7c, 0x59, 0x8c, 0x43, 0x12, 0xf1, 0x80, 0xd4, 0xdb,
+ 0x6e, 0xc9, 0xc3, 0xa8, 0x99, 0xdd, 0x8b, 0xd9, 0x4e, 0xea, 0xff, 0x60, 0x52,
+ 0x11, 0xb5, 0x53, 0xee, 0x6f, 0x7d, 0x93, 0x68, 0x3a, 0x55, 0x71, 0x41, 0xcc,
+ 0xd0, 0x08, 0x05, 0xaa, 0x91, 0x12, 0x94, 0x98, 0x69, 0xac, 0xd2, 0x58, 0x2c,
+ 0x8e, 0x73, 0x04, 0x6e, 0xd0, 0xf0, 0xe3, 0x1b, 0x5d, 0xd1, 0x84, 0x81, 0x1d,
+ 0xa4, 0xd6, 0x26, 0xb8,
+ ],
+ [
+ 0xf5, 0x3c, 0x07, 0x5c, 0x04, 0xdc, 0x6c, 0xee, 0x71, 0xcd, 0x1c, 0xd4, 0xee,
+ 0x57, 0x69, 0x05, 0x21, 0x72, 0xc3, 0xad,
+ ],
+ [
+ 0xaf, 0x4c, 0x8f, 0xf9, 0x6b, 0xf4, 0xe7, 0xc7, 0x13, 0xff, 0x59, 0x35, 0x2b,
+ 0x51, 0x35, 0xa4, 0x8c, 0xf4, 0xca, 0xc3, 0xb1, 0x56, 0xc1, 0xce, 0x09, 0x48,
+ 0x7c, 0x70, 0xd4, 0x2c, 0x03, 0x38,
+ ],
+ [
+ 0xd5, 0xb5, 0xf4, 0x47, 0xa6, 0xe3, 0xb4, 0xf1, 0xd7, 0x66, 0x71, 0x27, 0x4e,
+ 0x7d, 0xc2, 0x07, 0x98, 0xfb, 0x3d, 0x72, 0x38, 0xce, 0xf1, 0xd5, 0xf0, 0x75,
+ 0x36, 0xc1, 0x5d, 0xde, 0x71, 0x56, 0x9b, 0x8d, 0x04, 0xd2, 0xc4, 0x0d, 0x17,
+ 0xfc, 0x8d, 0x8d, 0xa5, 0xc9, 0x6a, 0xac, 0x5b, 0xf9,
+ ],
+ [
+ 0x11, 0x4f, 0xeb, 0x01, 0xba, 0xe2, 0x8d, 0x03, 0xfd, 0x28, 0x56, 0x5c, 0x4d,
+ 0x29, 0x40, 0xdc, 0x57, 0xf6, 0x19, 0xbe, 0x98, 0x37, 0x70, 0xa0, 0x63, 0x07,
+ 0x06, 0x3a, 0x42, 0x68, 0x34, 0x55, 0x36, 0xf7, 0x0f, 0x12, 0x0d, 0x1e, 0x49,
+ 0xf3, 0x0d, 0x35, 0xa4, 0x27, 0x5a, 0xa4, 0xf6, 0x02, 0x57, 0x84, 0x48, 0xb4,
+ 0xfc, 0x39, 0xcb, 0x32, 0x34, 0xc7, 0x55, 0xec, 0xfb, 0xcf, 0x45, 0x6a,
+ ]
+ ),
+ test_case!(
+ [
+ 0xd2, 0x36, 0xf4, 0x62, 0x69, 0x1b, 0x68, 0x21, 0x7a, 0xc4, 0x6a, 0xf3, 0x0e,
+ 0x1d, 0x09, 0xb9, 0xb6, 0x64, 0xc4, 0x8c, 0x11, 0x5a, 0xf8, 0x7a, 0xcc, 0x0d,
+ 0x3a, 0x0e, 0xd8, 0x28, 0xb6, 0xb1, 0xd4, 0xcc, 0x3d, 0xa9, 0xa2, 0xf6, 0x4b,
+ 0xd7, 0xc9, 0x8b, 0xed, 0xc3, 0xcc, 0xde, 0x83, 0x6d, 0xfd, 0x53, 0x94, 0xd1,
+ 0xbe, 0xa8, 0x7a, 0xcc, 0x0b, 0x27, 0xd6, 0x4a, 0xfa, 0x38, 0x4c, 0x11, 0x9b,
+ 0xa1, 0x80, 0x9f, 0xc3, 0xfc, 0xcd, 0xb3, 0x92, 0x88, 0x06, 0xbf, 0x66, 0x26,
+ 0x55, 0xa6, 0x0e, 0x1b, 0x25, 0x9c, 0x2b, 0xf4, 0x9d, 0x50, 0xf0, 0x9a, 0x15,
+ 0xa9, 0x55, 0x5a, 0xe5, 0x0d, 0x02, 0x8c, 0xf3, 0x7d, 0x9d, 0x2c, 0xfc, 0x00,
+ 0xdb, 0xf0, 0x98, 0x0d, 0xec, 0x35, 0x14, 0x8c, 0xc6, 0xed, 0x14, 0xc7, 0x4e,
+ 0xe7, 0x16, 0xbe, 0xb5, 0x0a,
+ ],
+ [
+ 0x06, 0xa5, 0xff, 0xb3, 0x35, 0xd0, 0x97, 0xca, 0x04, 0x6c, 0xd9, 0xcf, 0x8e,
+ 0x1c, 0x99, 0x6b, 0x5f, 0xe4, 0x8e, 0x07,
+ ],
+ [
+ 0x62, 0x1a, 0xe4, 0xc7, 0x4e, 0x8e, 0x18, 0x91, 0x14, 0xa8, 0x8c, 0x01, 0x76,
+ 0x99, 0x4a, 0x85, 0x67, 0xc7, 0x41, 0x58, 0x05, 0xde, 0xf4, 0xaf, 0x65, 0x99,
+ 0x62, 0x44, 0xb3, 0x21, 0x4a, 0x22,
+ ],
+ [
+ 0xac, 0x59, 0x70, 0xe8, 0xb0, 0x53, 0xa7, 0x6f, 0xf6, 0x15, 0x6e, 0xb6, 0xb7,
+ 0x80, 0xfe, 0xea, 0x6f, 0x1d, 0xff, 0x25, 0x75, 0xd1, 0x80, 0x49, 0x46, 0xbc,
+ 0xcc, 0x36, 0xd2, 0xa9, 0x82, 0xdf, 0x72, 0x55, 0xc8, 0x9d, 0x7c, 0x80, 0x6e,
+ 0x1e, 0xf8, 0x6d, 0x55, 0x4b, 0x31, 0xbf, 0xd6, 0xfc,
+ ],
+ [
+ 0x11, 0x4f, 0x70, 0x33, 0x2f, 0xf7, 0x1c, 0xc8, 0xa6, 0x9c, 0x91, 0x72, 0x4b,
+ 0xbf, 0x1c, 0x4e, 0x2c, 0x61, 0x05, 0x79, 0x36, 0xea, 0xd8, 0x84, 0x11, 0x5a,
+ 0xb0, 0x1f, 0x98, 0x4c, 0xe1, 0x7d, 0x0b, 0xb6, 0x7b, 0xec, 0xbc, 0x0b, 0x91,
+ 0x40, 0x5d, 0x86, 0xe4, 0x28, 0x52, 0x2b, 0x62, 0x8c, 0xcf, 0x9d, 0x63, 0xe2,
+ 0xb1, 0xf3, 0x8a, 0xd7, 0x6d, 0x7b, 0x4f, 0xd9, 0x82, 0x28, 0x6d, 0x6c,
+ ]
+ ),
+ test_case!(
+ [
+ 0xf0, 0x31, 0x92, 0xdd, 0x53, 0xed, 0x8c, 0x16, 0xd8, 0x98, 0xf6, 0xd0, 0xf1,
+ 0x5c, 0xad, 0xff, 0xf0, 0x4b, 0x8e, 0x6f, 0xc9, 0x5c, 0xb7, 0xc3, 0x16, 0xa1,
+ 0x2e, 0x15, 0xd5, 0x4f, 0x52, 0x6f, 0xaf, 0x4c, 0x14, 0xfb, 0x09, 0x18, 0xf8,
+ 0xb7, 0x76, 0x71, 0x6c, 0xd4, 0x7c, 0xd5, 0x69, 0x06, 0x31, 0x1f, 0x45, 0xce,
+ 0x9d, 0x1c, 0xfc, 0x2e, 0x14, 0xbb, 0x42, 0x1c, 0x6c, 0x12, 0x9a, 0x1c, 0xb9,
+ 0xac, 0x03, 0x04, 0x27, 0xc4, 0x87, 0x84, 0x2d, 0x64, 0xb5, 0x33, 0x5c, 0xf1,
+ 0x8c, 0xdf, 0x4a, 0x64, 0x71, 0x9d, 0xff, 0x1c, 0xd2, 0x60, 0xcd, 0x69, 0x1b,
+ 0x22, 0x30, 0x7f, 0x5c, 0x3b, 0x93, 0x97, 0x7b, 0xab, 0x7c, 0x54, 0xc8, 0xfa,
+ 0x8b, 0xde, 0x24, 0x7a, 0x0d, 0x86, 0x44, 0x67, 0xb0, 0xde, 0x8e, 0xde, 0xfc,
+ 0xd7, 0x24, 0xa4, 0xe5, 0x2d, 0x74,
+ ],
+ [
+ 0xe6, 0xe4, 0x77, 0xb9, 0xd7, 0x69, 0x8f, 0x64, 0x36, 0x03, 0x8a, 0x41, 0xab,
+ 0x63, 0xe4, 0x8c, 0x12, 0x13, 0x77, 0x74,
+ ],
+ [
+ 0xba, 0xef, 0xe7, 0x1a, 0xc5, 0x1e, 0xe0, 0x9e, 0x72, 0x9d, 0xfb, 0x7a, 0xad,
+ 0x90, 0xb4, 0x7c, 0x66, 0xb4, 0x48, 0xcc, 0xdf, 0xc5, 0xa4, 0x04, 0x2e, 0x67,
+ 0xf3, 0x33, 0x82, 0x8b, 0xab, 0x47,
+ ],
+ [
+ 0x56, 0xab, 0x79, 0x45, 0x8b, 0x2a, 0x28, 0xa9, 0x02, 0xf1, 0x03, 0x08, 0xd0,
+ 0x95, 0x43, 0x97, 0x4d, 0x2f, 0x2f, 0x7b, 0xd3, 0x7a, 0x58, 0x9d, 0x2b, 0xca,
+ 0x77, 0x06, 0x81, 0xbd, 0xf0, 0x03, 0xef, 0x18, 0x96, 0x6b, 0xb6, 0xec, 0x76,
+ 0x92, 0x22, 0xd2, 0x20, 0x4d, 0x94, 0x16, 0xc7, 0x3f,
+ ],
+ [
+ 0xe5, 0x52, 0x60, 0x65, 0x88, 0x60, 0x2e, 0x87, 0x4a, 0xf6, 0xe6, 0x3b, 0x58,
+ 0x28, 0xa6, 0x98, 0x84, 0x5d, 0x6f, 0xe3, 0xbf, 0x6f, 0x4a, 0x4a, 0x86, 0xcd,
+ 0x49, 0xad, 0xcb, 0xe9, 0xbc, 0xf8, 0x79, 0x73, 0x64, 0x45, 0x99, 0x1f, 0xbe,
+ 0xd5, 0x69, 0x09, 0x44, 0xa5, 0xb8, 0x55, 0xae, 0x71, 0x63, 0x9c, 0x85, 0x8b,
+ 0xbe, 0x0a, 0xa9, 0x3e, 0xfd, 0xdb, 0xcd, 0xda, 0x03, 0xb8, 0xe6, 0xd8,
+ ]
+ ),
+ test_case!(
+ [
+ 0xf7, 0x9c, 0x30, 0x50, 0xb6, 0x40, 0xb4, 0x7c, 0x71, 0x25, 0x3a, 0xa3, 0xb5,
+ 0xf1, 0x5a, 0x26, 0x8c, 0xaf, 0x3c, 0xc3, 0xe5, 0x5d, 0x18, 0x85, 0x6d, 0xf5,
+ 0x37, 0x26, 0x8f, 0x64, 0x00, 0xd5, 0x1e, 0x90, 0xbe, 0x84, 0xc7, 0x56, 0xfa,
+ 0x9b, 0xcf, 0xc9, 0x9d, 0x5c, 0x50, 0x1b, 0x44, 0xbf, 0x63, 0x25, 0xbf, 0xe3,
+ 0x0d, 0xd9, 0xea, 0xd3, 0x97, 0xc2, 0xfd, 0xd7, 0x86, 0x61, 0xb7, 0xbd, 0x15,
+ 0x2f, 0xa8, 0x16, 0xe9, 0x2f, 0xca, 0x16, 0x41, 0x6b, 0xbb, 0x05, 0x59, 0xfa,
+ 0x84, 0xcb, 0xf6, 0x00, 0xc9, 0xb9, 0xc6, 0xe6, 0x3e, 0x52, 0x68, 0x83, 0x7c,
+ 0x99, 0x53, 0x2e, 0x14, 0x98, 0xcf, 0x16, 0xe3, 0x80, 0xb7, 0x3c, 0x3f, 0x00,
+ 0x1d, 0xe4, 0xd6, 0x6c, 0x5c, 0x0b, 0x5f, 0xe0, 0xa4, 0x8d, 0x89, 0x9d, 0x6a,
+ 0x44, 0xa0, 0x75, 0x73, 0x59, 0xbf, 0xce,
+ ],
+ [
+ 0x18, 0x12, 0x5f, 0xe5, 0xef, 0xac, 0x2e, 0xd0, 0x6e, 0x37, 0x28, 0xb1, 0xfd,
+ 0x34, 0xa2, 0xe7, 0xca, 0xcb, 0xac, 0xa9,
+ ],
+ [
+ 0x63, 0x79, 0x63, 0xe9, 0xed, 0xbb, 0x5c, 0xaa, 0xec, 0xe1, 0xf1, 0xd1, 0xe3,
+ 0x5c, 0xa9, 0x95, 0x60, 0xe1, 0x05, 0x4c, 0xc5, 0x56, 0x28, 0x2f, 0x99, 0xf3,
+ 0x14, 0xb6, 0x18, 0xcc, 0x4e, 0x30,
+ ],
+ [
+ 0xb1, 0xd0, 0xaf, 0xf6, 0xee, 0xbd, 0xde, 0x45, 0xd7, 0xfa, 0x0b, 0x9a, 0x10,
+ 0x3a, 0x78, 0xf8, 0xf0, 0xef, 0xdd, 0x24, 0x90, 0x7b, 0x3b, 0x25, 0x1a, 0x78,
+ 0x43, 0xc7, 0x17, 0x01, 0xbf, 0x01, 0x57, 0xaa, 0xfc, 0x61, 0x09, 0x53, 0xba,
+ 0x0c, 0x02, 0x3a, 0x99, 0x38, 0xb0, 0xd0, 0x71, 0x04,
+ ],
+ [
+ 0x02, 0xce, 0x26, 0x11, 0xb3, 0x4b, 0x1c, 0x3b, 0x1d, 0x62, 0xca, 0xcf, 0x17,
+ 0x07, 0xf5, 0xbd, 0x12, 0x60, 0xd0, 0x30, 0x89, 0xa9, 0xb4, 0x74, 0x5b, 0xb3,
+ 0xa3, 0x7d, 0xb8, 0xec, 0xdb, 0xd2, 0x1d, 0x00, 0x6a, 0x62, 0x50, 0x0f, 0x54,
+ 0xf4, 0x67, 0x8c, 0x47, 0x19, 0x0d, 0x02, 0x02, 0x0e, 0x22, 0x30, 0xd8, 0xcd,
+ 0x39, 0xd8, 0xa5, 0x4c, 0x2a, 0x32, 0x11, 0xfa, 0x3e, 0x09, 0x1e, 0xd0,
+ ]
+ ),
+ test_case!(
+ [
+ 0x18, 0x8d, 0xb6, 0x50, 0xe7, 0xc6, 0x52, 0x64, 0xd8, 0x2d, 0x85, 0xd3, 0x01,
+ 0x9c, 0xbd, 0xd1, 0xe9, 0xe8, 0x2d, 0x52, 0x13, 0xee, 0x20, 0x0c, 0x4d, 0x83,
+ 0xe0, 0x05, 0xd1, 0x9e, 0x52, 0x8a, 0xea, 0xe2, 0x7c, 0x3c, 0xa5, 0x4c, 0x92,
+ 0x94, 0x6a, 0x39, 0x0a, 0x2d, 0xf5, 0x35, 0x16, 0xc1, 0x89, 0xe8, 0x16, 0xc5,
+ 0x3e, 0x29, 0xe6, 0xc6, 0xa1, 0x9f, 0xcc, 0xb3, 0x13, 0x51, 0xa5, 0xec, 0xc2,
+ 0x91, 0x94, 0x42, 0x64, 0xcf, 0x1b, 0xba, 0x9e, 0xc3, 0x89, 0x96, 0x9a, 0x81,
+ 0x2d, 0xb5, 0x04, 0xb0, 0xe3, 0xb3, 0xaf, 0x70, 0x0a, 0x20, 0x87, 0xde, 0x2f,
+ 0x7c, 0x01, 0xaa, 0x05, 0xa0, 0xe2, 0x6f, 0xd8, 0x68, 0x48, 0x94, 0x93, 0xa1,
+ 0x77, 0xe8, 0xd3, 0x8d, 0x1c, 0x09, 0x54, 0x10, 0x17, 0x21, 0xee, 0x4d, 0xbd,
+ 0x3b, 0xfb, 0x1a, 0xb6, 0xd7, 0x53, 0x7f, 0xf2,
+ ],
+ [
+ 0xc1, 0xb6, 0xed, 0x84, 0x79, 0xda, 0xa9, 0xc2, 0x06, 0xf0, 0x9c, 0xbf, 0x85,
+ 0xaf, 0xed, 0x82, 0x1f, 0xd6, 0x97, 0x01,
+ ],
+ [
+ 0x80, 0x5d, 0xdf, 0x7f, 0x0c, 0xfb, 0x96, 0x44, 0x4f, 0x26, 0xe4, 0x87, 0xa0,
+ 0x55, 0x94, 0x25, 0x68, 0x4f, 0x2d, 0x55, 0x1f, 0x67, 0x03, 0x7a, 0xd0, 0xcd,
+ 0x32, 0x13, 0x49, 0x3b, 0x1f, 0x35,
+ ],
+ [
+ 0x8c, 0xa5, 0x66, 0x01, 0xe5, 0x6e, 0xd6, 0x2e, 0x5b, 0x59, 0x46, 0x25, 0xa2,
+ 0xbd, 0xfa, 0xc7, 0xac, 0xf6, 0x03, 0x0b, 0x3f, 0xa0, 0xe9, 0x1f, 0x37, 0xba,
+ 0xbe, 0x1b, 0x57, 0x0c, 0xf8, 0xca, 0xb6, 0x36, 0xf7, 0x9b, 0x51, 0xf7, 0xa8,
+ 0xa9, 0x77, 0x9e, 0x42, 0x61, 0xeb, 0x20, 0x60, 0x42,
+ ],
+ [
+ 0x60, 0xea, 0x72, 0x81, 0x0f, 0x3e, 0xd4, 0xf7, 0x36, 0x0b, 0xd5, 0x63, 0x14,
+ 0xb8, 0x66, 0xef, 0xb2, 0x26, 0xd8, 0x86, 0x0e, 0x7a, 0x03, 0xd0, 0xdf, 0x97,
+ 0x88, 0xd9, 0x0f, 0xbb, 0x49, 0xaa, 0xbb, 0x83, 0x77, 0xbc, 0x6c, 0x09, 0x0d,
+ 0xd8, 0xaa, 0xb8, 0x89, 0xcd, 0x27, 0x12, 0xb2, 0xe3, 0xbc, 0x73, 0x83, 0xf2,
+ 0x55, 0xaa, 0x78, 0xb1, 0x66, 0x0f, 0x9e, 0xcf, 0xf1, 0x02, 0x1d, 0x71,
+ ]
+ ),
+ test_case!(
+ [
+ 0xa1, 0xb5, 0x83, 0x1e, 0x1d, 0xb1, 0x48, 0x1e, 0x38, 0x07, 0x6d, 0x3c, 0x1f,
+ 0xa4, 0x1f, 0x32, 0x2c, 0xcc, 0x0e, 0xac, 0xa2, 0x98, 0x86, 0xad, 0x42, 0x49,
+ 0xa4, 0x7b, 0x66, 0x2f, 0x2a, 0xde, 0x40, 0xf6, 0xc1, 0x0f, 0xe4, 0xfe, 0x96,
+ 0x08, 0x7a, 0xb4, 0x98, 0x06, 0x38, 0x07, 0x51, 0x52, 0x0b, 0xe9, 0x4c, 0x87,
+ 0x6b, 0xa0, 0x3f, 0x5b, 0xe3, 0x7e, 0x95, 0xfc, 0xa3, 0xe9, 0xad, 0xf1, 0x0b,
+ 0x1c, 0xfd, 0x85, 0x26, 0x4f, 0xf6, 0x1e, 0x1c, 0xa3, 0x9c, 0x71, 0x50, 0x91,
+ 0x62, 0x69, 0x22, 0x35, 0x40, 0x11, 0xfc, 0x71, 0x62, 0xfd, 0xcc, 0xc1, 0xcd,
+ 0x2b, 0x69, 0x2f, 0x0f, 0x77, 0x7e, 0x61, 0x4a, 0xf2, 0x34, 0x1e, 0x73, 0x1a,
+ 0xa7, 0xb5, 0xaf, 0x2f, 0x34, 0xb9, 0xdf, 0x49, 0xd0, 0x9e, 0x50, 0x53, 0x52,
+ 0x22, 0x47, 0x4b, 0x98, 0x45, 0x1b, 0x04, 0x82, 0x80,
+ ],
+ [
+ 0xac, 0xc6, 0x74, 0x48, 0x75, 0xe7, 0x23, 0x48, 0x75, 0x67, 0x6d, 0x6d, 0x9e,
+ 0xc7, 0x56, 0x5b, 0x8b, 0x57, 0x7a, 0xeb,
+ ],
+ [
+ 0x6f, 0xcf, 0x39, 0x76, 0xc5, 0x67, 0xdf, 0x53, 0xa7, 0xcb, 0x68, 0x78, 0x5d,
+ 0xbb, 0xa1, 0x51, 0xdf, 0xe8, 0xdd, 0x3c, 0x53, 0xc6, 0xa7, 0xad, 0xcd, 0x22,
+ 0x42, 0x27, 0x17, 0x58, 0x81, 0x21,
+ ],
+ [
+ 0x48, 0x1e, 0x1d, 0x8d, 0xbd, 0xf1, 0x4c, 0x82, 0x2e, 0x3b, 0xcf, 0x93, 0xc2,
+ 0xcf, 0x59, 0xcc, 0xc3, 0x46, 0x64, 0x38, 0xa0, 0x75, 0x90, 0x8d, 0x18, 0xd2,
+ 0xb4, 0xb8, 0x37, 0x06, 0xd4, 0x47, 0x3f, 0x4f, 0xb9, 0xb0, 0x55, 0x7b, 0x27,
+ 0x4f, 0x7c, 0x79, 0xcf, 0xfa, 0x3b, 0x4f, 0x2b, 0xc5,
+ ],
+ [
+ 0xab, 0xb8, 0x26, 0x0a, 0x70, 0x30, 0x88, 0xbb, 0xbb, 0x7d, 0x33, 0xa9, 0x19,
+ 0x2d, 0x82, 0x80, 0x5b, 0x3b, 0x68, 0x7b, 0x44, 0xb1, 0x81, 0x8a, 0xc7, 0x6b,
+ 0xb1, 0x49, 0xf2, 0x22, 0x49, 0x31, 0x0c, 0xf9, 0xb7, 0x03, 0xe8, 0xa5, 0xcf,
+ 0xcc, 0xd9, 0xad, 0xfe, 0xb3, 0x1c, 0x16, 0x9a, 0x0c, 0x2a, 0xb0, 0x4a, 0xda,
+ 0xaf, 0x1b, 0xe8, 0xb4, 0x70, 0xa6, 0x05, 0x54, 0xc2, 0x69, 0x23, 0x01,
+ ]
+ ),
+ test_case!(
+ [
+ 0x4b, 0x27, 0xe8, 0xbb, 0xdd, 0x90, 0x84, 0x61, 0x55, 0x4d, 0x1b, 0xf9, 0xdb,
+ 0xb6, 0x0b, 0x9f, 0xb6, 0xd5, 0x71, 0x94, 0x2b, 0x33, 0x6a, 0x2e, 0xd6, 0xfb,
+ 0xe6, 0x2e, 0x79, 0xce, 0x6e, 0xfa, 0xb1, 0xe0, 0x66, 0x1e, 0xef, 0x1a, 0x37,
+ 0xa5, 0x69, 0x7f, 0x0b, 0x3b, 0xf0, 0x09, 0x02, 0x3e, 0x98, 0x86, 0x70, 0x6c,
+ 0x9c, 0x9b, 0x72, 0x2d, 0x12, 0x81, 0x84, 0xfb, 0xac, 0x83, 0x42, 0xf7, 0xb7,
+ 0x46, 0x53, 0x31, 0x2a, 0x40, 0xf9, 0x98, 0xae, 0x5b, 0x05, 0x88, 0xaf, 0xd6,
+ 0xc1, 0x8e, 0xb6, 0x6f, 0x59, 0x2c, 0xaa, 0x44, 0x54, 0x6c, 0xf8, 0x0e, 0x09,
+ 0x99, 0x61, 0xd6, 0xc7, 0x6b, 0xd0, 0xc0, 0x34, 0x10, 0x2b, 0x3f, 0x61, 0x58,
+ 0xb1, 0xad, 0x3d, 0xdf, 0x34, 0xea, 0x0d, 0xe5, 0x02, 0xda, 0x7c, 0xb5, 0xe6,
+ 0x98, 0xa5, 0x20, 0x52, 0xc0, 0xbc, 0xb9, 0x05, 0x77, 0x93,
+ ],
+ [
+ 0x01, 0xfb, 0xc4, 0xd0, 0x5e, 0x7d, 0x64, 0x44, 0xb8, 0x70, 0xf9, 0x64, 0x71,
+ 0xbc, 0x2a, 0xa3, 0x37, 0xc7, 0x99, 0xf8,
+ ],
+ [
+ 0xdf, 0x36, 0x1a, 0x31, 0xd1, 0x6a, 0x5f, 0xf9, 0x3c, 0x20, 0xa9, 0xc6, 0x18,
+ 0x80, 0xcc, 0x30, 0x30, 0x9c, 0x01, 0x4e, 0x2c, 0x08, 0xfd, 0x33, 0xf1, 0x48,
+ 0x66, 0x9e, 0x33, 0xe6, 0x36, 0xa3,
+ ],
+ [
+ 0x70, 0x83, 0xb7, 0xa3, 0xb7, 0x1c, 0x52, 0x64, 0xec, 0xb3, 0x63, 0xc2, 0xee,
+ 0xcb, 0xa0, 0x57, 0xb5, 0x37, 0xcd, 0xc7, 0xc7, 0xdd, 0xf8, 0x3b, 0x21, 0x14,
+ 0x84, 0x2a, 0x65, 0xbb, 0x84, 0x91, 0x36, 0xde, 0x8b, 0x21, 0x36, 0x27, 0x12,
+ 0xf1, 0x28, 0xc9, 0xc8, 0x8a, 0x74, 0xdd, 0x7f, 0xb1,
+ ],
+ [
+ 0x30, 0xd8, 0x56, 0xd2, 0xc6, 0x90, 0xa0, 0x53, 0x2d, 0x58, 0x6e, 0x21, 0x0c,
+ 0xbd, 0x92, 0x03, 0xda, 0x89, 0x75, 0x1c, 0x37, 0xd0, 0xda, 0x6d, 0xd1, 0x98,
+ 0x03, 0x80, 0x62, 0x93, 0xe2, 0xef, 0x4e, 0x77, 0xde, 0xa8, 0x9d, 0x4a, 0x63,
+ 0xef, 0xf0, 0x5e, 0x93, 0xcb, 0x39, 0xbf, 0x26, 0x73, 0xcb, 0x26, 0x98, 0xe5,
+ 0x64, 0x08, 0xff, 0x26, 0xcf, 0xfc, 0xa4, 0x4c, 0x88, 0x74, 0x5d, 0x95,
+ ]
+ ),
+ test_case!(
+ [
+ 0x1a, 0x55, 0xe0, 0xb6, 0x41, 0x24, 0x2a, 0xed, 0x58, 0x88, 0x73, 0xee, 0x88,
+ 0x47, 0x3a, 0x98, 0x9d, 0x09, 0xad, 0x14, 0x60, 0xf8, 0x67, 0xd5, 0x77, 0xc0,
+ 0xa1, 0x5c, 0xa0, 0xfa, 0xaf, 0xee, 0x3d, 0x8b, 0xdc, 0xf5, 0xe4, 0x9e, 0x08,
+ 0xdb, 0xdf, 0x57, 0x1a, 0xcb, 0x0b, 0xab, 0x71, 0x5f, 0xfc, 0xef, 0xd3, 0x5d,
+ 0x11, 0x5a, 0xbd, 0x65, 0x37, 0x6e, 0xa4, 0x98, 0x53, 0x85, 0x75, 0xe8, 0x96,
+ 0x72, 0x64, 0xbe, 0x34, 0x9c, 0x4e, 0x4f, 0x22, 0x31, 0x10, 0x00, 0xf6, 0x46,
+ 0x65, 0x8b, 0xdc, 0x9e, 0x33, 0x9d, 0x5d, 0xe9, 0xa0, 0xc3, 0x1b, 0x98, 0xf8,
+ 0x81, 0x99, 0xba, 0xaa, 0xe5, 0xff, 0x3c, 0x2a, 0xd7, 0xc9, 0x80, 0x3a, 0x34,
+ 0x98, 0x67, 0x0e, 0xb9, 0x2e, 0x42, 0xa9, 0x8e, 0x82, 0xc1, 0xcb, 0x54, 0x87,
+ 0x44, 0x9b, 0xbf, 0x5f, 0x45, 0x19, 0xa0, 0x43, 0xe2, 0xb3, 0x41,
+ ],
+ [
+ 0x81, 0xb5, 0x99, 0x54, 0xaf, 0x53, 0x79, 0xe9, 0x25, 0xb3, 0x20, 0xb5, 0x88,
+ 0x47, 0x1d, 0x99, 0x43, 0xad, 0x33, 0x61,
+ ],
+ [
+ 0x15, 0xd6, 0xec, 0x09, 0xb8, 0xdc, 0xdd, 0xd9, 0x25, 0x55, 0x84, 0xf1, 0x81,
+ 0xab, 0xdd, 0xf5, 0x62, 0x4f, 0x3e, 0x3f, 0x8e, 0x34, 0x19, 0x8f, 0x14, 0x85,
+ 0xed, 0xd3, 0xb7, 0xc1, 0x31, 0x54,
+ ],
+ [
+ 0x5a, 0xb0, 0x46, 0x17, 0x1b, 0x70, 0x20, 0x9c, 0xbc, 0x6c, 0x24, 0xfb, 0xd3,
+ 0x3e, 0x77, 0x3e, 0x52, 0x0c, 0x56, 0x75, 0x52, 0xa3, 0x12, 0x76, 0x69, 0xd3,
+ 0x0d, 0x38, 0x45, 0x41, 0x3c, 0x21, 0x86, 0xa8, 0x57, 0xba, 0xb5, 0xeb, 0x32,
+ 0x45, 0xec, 0x46, 0xd0, 0xa7, 0xcf, 0x5b, 0x17, 0x2c,
+ ],
+ [
+ 0x6c, 0x5d, 0x94, 0x61, 0x1e, 0xe6, 0xcb, 0xa0, 0xda, 0xcf, 0xcf, 0xca, 0x7c,
+ 0x40, 0xba, 0xb2, 0x97, 0x0f, 0x8c, 0xbc, 0xd3, 0x6e, 0x60, 0x04, 0xa5, 0x64,
+ 0x61, 0xa0, 0xd3, 0x7d, 0x8b, 0x0a, 0x56, 0x4d, 0x53, 0xad, 0x5f, 0xdc, 0x5c,
+ 0x09, 0x73, 0x29, 0x0d, 0xdd, 0xf5, 0x32, 0xc1, 0x1e, 0xec, 0xf2, 0x43, 0xc4,
+ 0xd0, 0x93, 0x20, 0x20, 0xed, 0xd0, 0xa7, 0x0d, 0xcb, 0x3e, 0x46, 0xe3,
+ ]
+ ),
+ ];
+ }
+}
diff --git a/src/insecure.rs b/src/insecure.rs
new file mode 100644
index 0000000..ef255b3
--- /dev/null
+++ b/src/insecure.rs
@@ -0,0 +1,22 @@
+// Copyright 2018 Google LLC
+//
+// Use of this source code is governed by an MIT-style
+// license that can be found in the LICENSE file or at
+// https://opensource.org/licenses/MIT.
+
+//! WARNING: INSECURE CRYPTOGRAPHIC OPERATIONS.
+//!
+//! This module contains cryptographic operations which are considered insecure.
+//! These operations should only be used for compatibility with legacy systems,
+//! but never in new systems!
+
+#![deprecated(note = "insecure cryptographic operations")]
+
+#[allow(deprecated)]
+pub use hash::insecure_sha1_digest::InsecureSha1Digest;
+#[allow(deprecated)]
+pub use hmac::insecure_hmac_sha1::InsecureHmacSha1;
+
+#[cfg(feature = "kdf")]
+#[allow(deprecated)]
+pub use kdf::insecure_pbkdf2_hmac_sha1::insecure_pbkdf2_hmac_sha1;
diff --git a/src/kdf.rs b/src/kdf.rs
new file mode 100644
index 0000000..0d48ee8
--- /dev/null
+++ b/src/kdf.rs
@@ -0,0 +1,136 @@
+// Copyright 2018 Google LLC
+//
+// Use of this source code is governed by an MIT-style
+// license that can be found in the LICENSE file or at
+// https://opensource.org/licenses/MIT.
+
+//! Key Derivation Functions (KDFs).
+//!
+//! KDFs are low-level primitives often used to construct higher-level
+//! protocols. Unless you're sure that this is what you need, you should
+//! probably be using something else. In particular:
+//! - If you need password verification, see the [`password`] module.
+//!
+//! [`password`]: ::password
+
+use std::num::NonZeroU32;
+
+use boringssl;
+use hash::Hasher;
+
+/// The PBKDF2 Key Derivation Function.
+///
+/// `pbkdf2` computes `iter` iterations of PBKDF2 of `password` and `salt`,
+/// using an HMAC based on the hash function `H`. It stores the result in
+/// `out_key`. Note that PBKDF2 can produce variable-length output, so it will
+/// always fill the entirety of `out_key` regardless of its length.
+///
+/// PBKDF2 is defined in RSA Security LLC's Public Key Cryptography Standards #5
+/// (PKCS #5) v2.0. For details, see [RFC 2898 Section 5.2].
+///
+/// # Security
+///
+/// While PBKDF2 can produce any amount of key output, the entropy of its output
+/// is bounded by the internal state. Be careful that the output key has enough
+/// entropy for your needs. See [RFC 2898 Appendix B.1] for a discussion on
+/// calculating the effective entropy of PBKDF2. Also remember that new attacks
+/// are sometimes discovered, and it is your responsibility to keep up with the
+/// latest attacks; RFC 2898's analysis may not be valid forever!
+///
+/// [RFC 2898 Section 5.2]: https://tools.ietf.org/html/rfc2898#section-5.2
+/// [RFC 2898 Appendix B.1]: https://tools.ietf.org/html/rfc2898#appendix-B.1
+#[must_use]
+pub fn pbkdf2<H: Hasher>(password: &[u8], salt: &[u8], iters: NonZeroU32, out_key: &mut [u8]) {
+ // PKCS5_PBKDF2_HMAC can only fail on OOM or if iters is 0.
+ boringssl::pkcs5_pbkdf2_hmac(password, salt, iters.get(), &H::evp_md(), out_key).unwrap();
+}
+
+#[cfg(feature = "insecure")]
+pub(crate) mod insecure_pbkdf2_hmac_sha1 {
+ use std::num::NonZeroU32;
+
+ #[allow(deprecated)]
+ use hash::InsecureSha1;
+ use kdf::pbkdf2;
+
+ /// INSECURE: The PBKDF2 Key Derivation Function over HMAC-SHA1.
+ ///
+ /// # Security
+ ///
+ /// PBKDF2-HMAC-SHA1 is considered insecure, and should only be used for
+ /// compatibility with legacy applications.
+ ///
+ /// # Behavior
+ ///
+ /// `pbkdf2_hmac_sha1` computes `iter` iterations of PBKDF2-HMAC-SHA1 of
+ /// `password` and `salt`. It stores the result in `out_key`.
+ ///
+ /// PBKDF2 is defined in RSA Security LLC's Public Key Cryptography
+ /// Standards #5 (PKCS #5) v2.0. For details, see [RFC 2898 Section 5.2].
+ ///
+ /// # Further Security Considerations
+ ///
+ /// While PBKDF2 can produce any amount of key output, the entropy of its
+ /// output is bounded by the internal state. Be careful that the output key
+ /// has enough entropy for your needs. See [RFC 2898 Appendix B.1] for a
+ /// discussion on calculating the effective entropy of PBKDF2, but keep in
+ /// mind that SHA-1's insecurities may affect this analysis! Also remember
+ /// that new attacks are sometimes discovered, and it is your responsibility
+ /// to keep up with the latest attacks; RFC 2898's analysis may not be valid
+ /// forever!
+ ///
+ /// [RFC 2898 Section 5.2]: https://tools.ietf.org/html/rfc2898#section-5.2
+ /// [RFC 2898 Appendix B.1]: https://tools.ietf.org/html/rfc2898#appendix-B.1
+ #[must_use]
+ #[deprecated(note = "PBKDF2-HMAC-SHA1 is considered insecure")]
+ pub fn insecure_pbkdf2_hmac_sha1(
+ password: &[u8], salt: &[u8], iters: NonZeroU32, out_key: &mut [u8],
+ ) {
+ #[allow(deprecated)]
+ pbkdf2::<InsecureSha1>(password, salt, iters, out_key)
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use hash::*;
+
+ #[test]
+ fn test_smoke() {
+ for password_len in 0..8 {
+ for salt_len in 0..8 {
+ for iters in 1..8 {
+ for out_key_len in 0..8 {
+ fn test<H: Hasher>(
+ password_len: usize, salt_len: usize, iters: u32, out_key_len: usize,
+ ) {
+ let password = [0, 1, 2, 3, 4, 5, 6, 7];
+ let salt = [0, 1, 2, 3, 4, 5, 6, 7];
+ let mut out_key_0 = [0; 8];
+ let mut out_key_1 = [0; 8];
+
+ pbkdf2::<H>(
+ &password[..password_len],
+ &salt[..salt_len],
+ NonZeroU32::new(iters).unwrap(),
+ &mut out_key_0[..out_key_len],
+ );
+ pbkdf2::<H>(
+ &password[..password_len],
+ &salt[..salt_len],
+ NonZeroU32::new(iters).unwrap(),
+ &mut out_key_1[..out_key_len],
+ );
+ assert_eq!(&out_key_0[..out_key_len], &out_key_1[..out_key_len]);
+ }
+
+ test::<Sha256>(password_len, salt_len, iters, out_key_len);
+ test::<Sha384>(password_len, salt_len, iters, out_key_len);
+ test::<Sha512>(password_len, salt_len, iters, out_key_len);
+ }
+ }
+ }
+ }
+ }
+}
diff --git a/src/lib.rs b/src/lib.rs
new file mode 100644
index 0000000..468ee9b
--- /dev/null
+++ b/src/lib.rs
@@ -0,0 +1,167 @@
+// Copyright 2018 Google LLC
+//
+// Use of this source code is governed by an MIT-style
+// license that can be found in the LICENSE file or at
+// https://opensource.org/licenses/MIT.
+
+//! Cryptography in Rust.
+//!
+//! `mundane` is a Rust cryptography library backed by BoringSSL that is
+//! difficult to misuse, ergonomic, and performant (in that order).
+//!
+//! # Features
+//!
+//! By default, `mundane` provides only high-level cryptographic primitives.
+//! Unless you are implementing cryptographic protocols, these high-level
+//! primitives should be all you need. However, if you are sure that you need
+//! something lower level, `mundane` provides features to enable a number of
+//! different low level primitives.
+//!
+//! WARNING: Being low level, these primitives provide the programmer with more
+//! degrees of freedom. There are more conditions that the programmer must meet
+//! in order to guarantee security, and thus more ways for the programmer to
+//! shoot themself in the foot. Please only use these primitives if you're aware
+//! of the risks and are comfortable with the responsibility of using them
+//! correctly!
+//!
+//! **Features**
+//!
+//! | Name | Description |
+//! | ------------ | ------------------------ |
+//! | `kdf` | Key derivation functions |
+//! | `rand-bytes` | Generate random bytes |
+//!
+//! # Insecure Operations
+//!
+//! `mundane` supports one additional feature not listed in the previous
+//! section: `insecure`. This enables some cryptographic primitives which are
+//! today considered insecure. These should only be used for compatibility with
+//! legacy systems, but never in new systems! When the `insecure` feature is
+//! used, an `insecure` module is added to the crate root. All insecure
+//! primitives are exposed through this module.
+
+#![doc(html_root_url = "https://docs.rs/mundane/0.2.0")]
+#![deny(missing_docs)]
+#![deny(warnings)]
+#![feature(tool_lints)]
+#![allow(stable_features)]
+// just in case we forget to add #[forbid(unsafe_code)] on new module
+// definitions
+#![deny(unsafe_code)]
+
+#[macro_use]
+mod macros;
+
+// Forbid unsafe code except in the boringssl module.
+#[allow(unsafe_code)]
+mod boringssl;
+#[forbid(unsafe_code)]
+pub mod hash;
+#[forbid(unsafe_code)]
+pub mod hmac;
+#[cfg(feature = "insecure")]
+#[forbid(unsafe_code)]
+pub mod insecure;
+#[cfg(feature = "kdf")]
+#[forbid(unsafe_code)]
+pub mod kdf;
+#[forbid(unsafe_code)]
+pub mod password;
+#[forbid(unsafe_code)]
+pub mod public;
+#[forbid(unsafe_code)]
+mod util;
+
+use std::fmt::{self, Debug, Display, Formatter};
+
+use boringssl::BoringError;
+
+/// Reads cryptographically-secure random bytes.
+///
+/// This is a low-level primitive often used to construct higher-level
+/// protocols. Unless you're sure that this is what you need, you should
+/// probably be using something else. For example, all key types can be randomly
+/// generated using higher-level functions (e.g., [`EcPrivKey::generate`]),
+/// scrypt nonces are generated using the [`scrypt_generate`] function, etc.
+///
+/// [`EcPrivKey::generate`]: ::public::ec::EcPrivKey::generate
+/// [`scrypt_generate`]: ::password::scrypt::scrypt_generate
+#[cfg(feature = "rand-bytes")]
+pub fn rand_bytes(bytes: &mut [u8]) {
+ boringssl::rand_bytes(bytes);
+}
+
+/// Errors generated by this crate.
+///
+/// `Error` represents two types of errors: errors generated by BoringSSL, and
+/// errors generated by the Rust code in this crate. When printed (using either
+/// `Display` or `Debug`), BoringSSL errors are of the form `boringssl:
+/// <error>`, while errors generated by Rust code are of the form `<error>`.
+pub struct Error(ErrorInner);
+
+impl Error {
+ fn new(s: String) -> Error {
+ Error(ErrorInner::Mundane(s))
+ }
+}
+
+#[doc(hidden)]
+impl From<BoringError> for Error {
+ fn from(err: BoringError) -> Error {
+ Error(ErrorInner::Boring(err))
+ }
+}
+
+impl Display for Error {
+ fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> {
+ match &self.0 {
+ ErrorInner::Mundane(err) => write!(f, "{}", err),
+ ErrorInner::Boring(err) => write!(f, "boringssl: {}", err),
+ }
+ }
+}
+
+impl Debug for Error {
+ fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> {
+ match &self.0 {
+ ErrorInner::Mundane(err) => write!(f, "{}", err),
+
+ ErrorInner::Boring(err) => {
+ if err.stack_depth() == 1 {
+ // Either there was no stack trace, or the stack trace only
+ // contained a single frame. In either case, don't bother
+ // printing a preceding newline.
+ write!(f, "boringssl: {:?}", err)
+ } else {
+ // There's a multi-line stack trace, so print a preceding
+ // newline.
+ write!(f, "boringssl:\n{:?}", err)
+ }
+ }
+ }
+ }
+}
+
+impl std::error::Error for Error {}
+
+enum ErrorInner {
+ Mundane(String),
+ Boring(BoringError),
+}
+
+#[cfg(test)]
+mod tests {
+ use super::Error;
+
+ #[test]
+ fn test_send() {
+ fn assert_send<T: Send>() {}
+ assert_send::<Error>();
+ }
+
+ #[test]
+ fn test_sync() {
+ fn assert_sync<T: Sync>() {}
+ assert_sync::<Error>();
+ }
+}
diff --git a/src/macros.rs b/src/macros.rs
new file mode 100644
index 0000000..4c98d13
--- /dev/null
+++ b/src/macros.rs
@@ -0,0 +1,15 @@
+// Copyright 2018 Google LLC
+//
+// Use of this source code is governed by an MIT-style
+// license that can be found in the LICENSE file or at
+// https://opensource.org/licenses/MIT.
+
+macro_rules! impl_debug {
+ ($type:ty, $str:expr) => {
+ impl ::std::fmt::Debug for $type {
+ fn fmt(&self, f: &mut ::std::fmt::Formatter) -> Result<(), ::std::fmt::Error> {
+ write!(f, $str)
+ }
+ }
+ };
+}
diff --git a/src/password.rs b/src/password.rs
new file mode 100644
index 0000000..e89f0eb
--- /dev/null
+++ b/src/password.rs
@@ -0,0 +1,253 @@
+// Copyright 2018 Google LLC
+//
+// Use of this source code is governed by an MIT-style
+// license that can be found in the LICENSE file or at
+// https://opensource.org/licenses/MIT.
+
+//! Password verification.
+
+/// The scrypt password hashing function.
+///
+/// scrypt was originally proposed in [Stronger Key Derivation via Sequential
+/// Memory-Hard Functions] and standardized in [RFC 7914].
+///
+/// A note on terminology: scrypt is technically a key derivation function, and
+/// its output is thus technically a key. However, we expose it here only for
+/// the purposes of password verification, and thus we use the term "hash" to
+/// refer to its output.
+///
+/// [Stronger Key Derivation via Sequential Memory-Hard Functions]: https://www.tarsnap.com/scrypt/scrypt.pdf
+/// [RFC 7914]: https://tools.ietf.org/html/rfc7914
+pub mod scrypt {
+ use boringssl;
+
+ // NOTE(joshlf): These are both set to 32 bytes (256 bits). This is probably
+ // overkill (128 bits is probably fine, as the lack of entropy in password
+ // hashes usually comes primarily from the passwords themselves), but better
+ // safe than sorry. Note that this is consistent with the Go scrypt
+ // documentation examples (https://godoc.org/golang.org/x/crypto/scrypt),
+ // while Go's bcrypt implementation
+ // (https://godoc.org/golang.org/x/crypto/bcrypt) uses a 128-bit salt and a
+ // 192-bit hash.
+
+ /// The length of an scrypt hash.
+ ///
+ /// The value of this constant - 32 - is considered part of this API. Any
+ /// changes to it will be considered breaking changes.
+ pub const SCRYPT_HASH_LEN: usize = 32;
+ /// The length of an scrypt salt.
+ ///
+ /// The value of this constant - 32 - is considered part of this API. Any
+ /// changes to it will be considered breaking changes.
+ pub const SCRYPT_SALT_LEN: usize = 32;
+
+ /// Recommended parameters for a production server.
+ ///
+ /// `SCRYPT_PARAMS_SERVER` is an appropriate set of parameters for running
+ /// scrypt on a production server in 2018. It targets 100ms of execution
+ /// time per generation or verification.
+ ///
+ /// The value of this constant may be updated periodically in order to keep
+ /// up with hardware trends.
+ pub const SCRYPT_PARAMS_SERVER: ScryptParams = ScryptParams {
+ // NOTE(joshlf): These were taken from the Go scrypt implementation
+ // (https://godoc.org/golang.org/x/crypto/scrypt) on 08/14/2018.
+ N: 32768,
+ r: 8,
+ p: 1,
+ };
+
+ /// Recommended paramaters for a laptop.
+ ///
+ /// `SCRYPT_PARAMS_LAPTOP` is an appropriate set of parameters for running
+ /// scrypt on a medium-range laptop in 2018. It targets 100ms of execution
+ /// time per generation or verification.
+ ///
+ /// The value of this constant may be updated periodically in order to keep
+ /// up with hardware trends.
+ pub const SCRYPT_PARAMS_LAPTOP: ScryptParams = ScryptParams {
+ // NOTE(joshlf): These were benchmarked on my laptop (2017 MacBook Pro
+ // 13-inch with a 3.5 GHz Intel Core i7 - model identifier
+ // MacBookPro14,2) on 08/14/2018.
+ N: 16384,
+ r: 8,
+ p: 1,
+ };
+
+ /// The parameters to the scrypt function.
+ ///
+ /// These parameters determine how much effort will be required in order to
+ /// generate or verify an scrypt hash. "Effort" here refers to utilization
+ /// of of CPU, memory, and memory bandwidth. For more details on what these
+ /// parameters mean and their implications, see [The scrypt Parameters]. For
+ /// sane defaults, see the `SCRYPT_PARAMS_XXX` constants.
+ ///
+ /// [The scrypt Parameters]: https://blog.filippo.io/the-scrypt-parameters/
+ #[allow(non_snake_case)]
+ #[allow(missing_docs)]
+ #[derive(Debug, Copy, Clone)]
+ pub struct ScryptParams {
+ // NOTE(joshlf): These are private so that the user is forced to use one
+ // of our presets. If this turns out to be too brittle, it might be
+ // worth considering making these public, and simply discouraging
+ // (perhaps via a deprecation attribute) setting them directly.
+ N: u64,
+ r: u64,
+ p: u64,
+ }
+
+ impl ScryptParams {
+ /// Gets the parameter N.
+ #[allow(non_snake_case)]
+ #[must_use]
+ pub fn N(&self) -> u64 {
+ self.N
+ }
+
+ /// Gets the parameter r.
+ #[must_use]
+ pub fn r(&self) -> u64 {
+ self.r
+ }
+
+ /// Gets the parameter p.
+ #[must_use]
+ pub fn p(&self) -> u64 {
+ self.p
+ }
+ }
+
+ // Don't put a limit on the memory used by scrypt; it's too prone to
+ // failure. Instead, rely on choosing sane defaults for N, r, and p to
+ // ensure that we don't use too much memory.
+ const SCRYPT_MAX_MEM: usize = usize::max_value();
+
+ // TODO(joshlf): Provide a custom Debug impl for ScryptHash?
+
+ /// The output of the scrypt password hashing function.
+ #[must_use]
+ #[allow(non_snake_case)]
+ #[derive(Debug, Copy, Clone)]
+ pub struct ScryptHash {
+ hash: [u8; SCRYPT_HASH_LEN],
+ salt: [u8; SCRYPT_SALT_LEN],
+ params: ScryptParams,
+ }
+
+ impl ScryptHash {
+ // NOTE(joshlf): Normally, having three different parameters in a row of
+ // the same type would be dangerous because it's too easy to
+ // accidentally pass arguments in the wrong order. In this particular
+ // case, it's less of a concern because ScryptHash is only passed to the
+ // scrypt_verify function, so the worst that reordering these parameters
+ // can due is cause a valid hash to be mistakenly rejected as invalid.
+ // If this were a constructor on ScryptParams, which is passed as an
+ // argument to scrypt_generate, then a mistake might lead to
+ // accidentally generating a hash with weak security parameters, which
+ // would be a problem.
+
+ /// Constructs a new `ScryptHash`.
+ #[allow(non_snake_case)]
+ #[must_use]
+ pub fn new(
+ hash: [u8; SCRYPT_HASH_LEN], salt: [u8; SCRYPT_SALT_LEN], N: u64, r: u64, p: u64,
+ ) -> ScryptHash {
+ ScryptHash {
+ hash,
+ salt,
+ params: ScryptParams { N, r, p },
+ }
+ }
+
+ /// Gets the hash.
+ #[must_use]
+ pub fn hash(&self) -> &[u8; SCRYPT_HASH_LEN] {
+ &self.hash
+ }
+
+ /// Gets the salt.
+ #[must_use]
+ pub fn salt(&self) -> &[u8; SCRYPT_SALT_LEN] {
+ &self.salt
+ }
+
+ /// Gets the params.
+ #[must_use]
+ pub fn params(&self) -> ScryptParams {
+ self.params
+ }
+ }
+
+ /// Generates an scrypt hash for the given password.
+ ///
+ /// `scrypt_generate` uses scrypt to generate a hash for the given
+ /// `password` using the provided `params`.
+ #[must_use]
+ pub fn scrypt_generate(password: &[u8], params: &ScryptParams) -> ScryptHash {
+ let mut salt = [0u8; SCRYPT_SALT_LEN];
+ boringssl::rand_bytes(&mut salt);
+ let mut hash = [0u8; SCRYPT_HASH_LEN];
+ // Can only fail on OOM, max_mem exceeded (SCRYPT_MAX_MEM is max usize,
+ // so that definitely won't happen), or if any of the parameters are
+ // invalid (which would be a bug on our part). Thus, we unwrap.
+ boringssl::evp_pbe_scrypt(
+ password,
+ &salt,
+ params.N,
+ params.r,
+ params.p,
+ SCRYPT_MAX_MEM,
+ &mut hash,
+ ).unwrap();
+ ScryptHash {
+ hash,
+ salt,
+ params: *params,
+ }
+ }
+
+ /// Verifies a password against an scrypt hash.
+ ///
+ /// `scrypt_verify` verifies that `password` is the same password that was
+ /// used to generate `hash` using scrypt.
+ #[must_use]
+ pub fn scrypt_verify(password: &[u8], hash: &ScryptHash) -> bool {
+ let mut out_hash = [0u8; SCRYPT_HASH_LEN];
+ if boringssl::evp_pbe_scrypt(
+ password,
+ &hash.salt,
+ hash.params.N,
+ hash.params.r,
+ hash.params.p,
+ SCRYPT_MAX_MEM,
+ &mut out_hash,
+ ).is_err()
+ {
+ return false;
+ }
+ boringssl::crypto_memcmp(&out_hash, &hash.hash)
+ }
+
+ #[cfg(test)]
+ mod tests {
+ use super::*;
+
+ #[test]
+ fn test_scrypt() {
+ for _ in 0..16 {
+ let mut pass = [0; 128];
+ boringssl::rand_bytes(&mut pass);
+ // target 1 second of execution for this test on a laptop
+ let mut params = SCRYPT_PARAMS_LAPTOP;
+ params.N /= 4;
+ let hash = scrypt_generate(&pass, ¶ms);
+ assert!(
+ scrypt_verify(&pass, &hash),
+ "pass: {:?}, hash: {:?}",
+ &pass[..],
+ hash
+ );
+ }
+ }
+ }
+}
diff --git a/src/public/ec/curve.rs b/src/public/ec/curve.rs
new file mode 100644
index 0000000..f7e0da7
--- /dev/null
+++ b/src/public/ec/curve.rs
@@ -0,0 +1,144 @@
+// Copyright 2018 Google LLC
+//
+// Use of this source code is governed by an MIT-style
+// license that can be found in the LICENSE file or at
+// https://opensource.org/licenses/MIT.
+
+use std::borrow::Cow;
+use std::fmt::{self, Debug, Display, Formatter};
+use std::os::raw::c_int;
+
+use boringssl::{self, BoringError};
+use util::Sealed;
+use Error;
+
+/// The meat of the `Curve` trait.
+///
+/// We put the meat of the trait - an inner `Curve` trait which actually has
+/// methods on it - in a separate, private module because we don't want these
+/// methods to be visible to users.
+mod inner {
+ use Error;
+
+ use boringssl::{self, CRef};
+ use util::Sealed;
+
+ /// An elliptic curve.
+ ///
+ /// `PCurve` is implemented by `P256`, `P384`, `P521`.
+ pub trait PCurve: Sized + Sealed {
+ /// Returns this curve's NID.
+ ///
+ /// Callers are allowed to assume that this NID is a valid one, and are
+ /// allowed to panic if it is not.
+ fn nid() -> i32;
+
+ /// Returns the group named by `Self::nid()`.
+ fn group() -> CRef<'static, boringssl::EC_GROUP> {
+ CRef::ec_group_new_by_curve_name(Self::nid()).unwrap()
+ }
+
+ /// Validate that an `EC_GROUP` is matches this group.
+ ///
+ /// If `group` is not equal to the curve's group, `from_group` returns
+ /// an error.
+ fn validate_group(group: CRef<boringssl::EC_GROUP>) -> Result<(), Error>;
+ }
+}
+
+/// A NIST P elliptic curve.
+///
+/// `PCurve` is implemented by [`P256`], [`P384`], and [`P521`]. The P-224 curve
+/// is considered insecure, and thus is not supported.
+///
+/// The P curves are defined by NIST and are used in the ECDSA and ECDH
+/// algorithms.
+///
+/// [`P256`]: ::public::ec::P256
+/// [`P384`]: ::public::ec::P384
+/// [`P521`]: ::public::ec::P521
+pub trait PCurve: Sized + Copy + Clone + Default + Display + Debug + self::inner::PCurve {}
+
+/// The P-256 curve.
+#[derive(Copy, Clone, Default, Debug, Eq, PartialEq, Hash)]
+pub struct P256;
+/// The P-384 curve.
+#[derive(Copy, Clone, Default, Debug, Eq, PartialEq, Hash)]
+pub struct P384;
+/// The P-521 curve.
+#[derive(Copy, Clone, Default, Debug, Eq, PartialEq, Hash)]
+pub struct P521;
+
+impl Display for P256 {
+ fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> {
+ write!(f, "P-256")
+ }
+}
+impl Display for P384 {
+ fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> {
+ write!(f, "P-384")
+ }
+}
+impl Display for P521 {
+ fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> {
+ write!(f, "P-521")
+ }
+}
+
+const NID_P256: i32 = boringssl::NID_X9_62_prime256v1 as i32;
+const NID_P384: i32 = boringssl::NID_secp384r1 as i32;
+const NID_P521: i32 = boringssl::NID_secp521r1 as i32;
+
+macro_rules! impl_curve {
+ ($name:ident, $str:expr, $nid:ident) => {
+ impl self::inner::PCurve for $name {
+ fn nid() -> i32 {
+ $nid
+ }
+ fn validate_group(group: boringssl::CRef<boringssl::EC_GROUP>) -> Result<(), ::Error> {
+ let nid = group.ec_group_get_curve_name();
+ if nid != $nid {
+ return Err(::Error::new(format!(
+ concat!("unexpected curve: got {}; want ", $str),
+ nid_name(nid).unwrap(),
+ )));
+ }
+ Ok(())
+ }
+ }
+
+ impl Sealed for $name {}
+ impl PCurve for $name {}
+ };
+}
+
+impl_curve!(P256, "P-256", NID_P256);
+impl_curve!(P384, "P-384", NID_P384);
+impl_curve!(P521, "P-521", NID_P521);
+
+/// A dynamic representation of a curve.
+pub enum CurveKind {
+ P256,
+ P384,
+ P521,
+}
+
+impl CurveKind {
+ /// Get the `CurveKind` associated with a NID.
+ pub fn from_nid(nid: i32) -> Result<CurveKind, Error> {
+ match nid {
+ self::NID_P256 => Ok(CurveKind::P256),
+ self::NID_P384 => Ok(CurveKind::P384),
+ self::NID_P521 => Ok(CurveKind::P521),
+ _ => Err(Error::new(format!(
+ "unsupported curve: {}",
+ nid_name(nid).unwrap()
+ ))),
+ }
+ }
+}
+
+// NOTE: Can only return an error due to an unknown NID
+fn nid_name(nid: c_int) -> Result<Cow<'static, str>, BoringError> {
+ Ok(boringssl::ec_curve_nid2nist(nid)?.to_string_lossy())
+}
diff --git a/src/public/ec/mod.rs b/src/public/ec/mod.rs
new file mode 100644
index 0000000..93a725a
--- /dev/null
+++ b/src/public/ec/mod.rs
@@ -0,0 +1,726 @@
+// Copyright 2018 Google LLC
+//
+// Use of this source code is governed by an MIT-style
+// license that can be found in the LICENSE file or at
+// https://opensource.org/licenses/MIT.
+
+//! Elliptic Curve-based cryptographic algorithms over NIST P curves.
+//!
+//! This module only supports elliptic curve cryptography over NIST's P curves,
+//! defined in FIPS 186-3. These are the P-256, P-384, and P-521 curves (P-224
+//! is considered insecure, and thus is not supported). The ECDSA and ECDH
+//! algorithms are both defined over P curves, and so are exposed in this
+//! module.
+//!
+//! Other elliptic curve algorithms on non-P curves live in other modules (e.g.,
+//! operations on the Edwards 25519 curve live in the [`ed25519`] module).
+//!
+//! [`ed25519`]: ::public::ed25519
+
+mod curve;
+
+pub use public::ec::curve::{PCurve, P256, P384, P521};
+
+use std::fmt::{self, Debug, Formatter};
+
+use boringssl::{CHeapWrapper, CStackWrapper};
+use public::ec::curve::CurveKind;
+use public::ec::inner::EcKey;
+use public::{inner::DerKey, DerPrivateKey, DerPublicKey, PrivateKey, PublicKey};
+use util::Sealed;
+use Error;
+
+mod inner {
+ use std::marker::PhantomData;
+
+ use boringssl::{self, BoringError, CHeapWrapper, CStackWrapper};
+ use public::ec::curve::PCurve;
+ use public::inner::BoringDerKey;
+ use Error;
+
+ // A convenience wrapper around boringssl::EC_KEY.
+ //
+ // EcKey maintains the following invariants:
+ // - The key is valid.
+ // - The key is on the curve C.
+ //
+ // This is marked pub and put in this (non-public) module so that using it in impls of
+ // the Key trait don't result in public-in-private errors.
+ #[derive(Clone)]
+ pub struct EcKey<C: PCurve> {
+ pub key: CHeapWrapper<boringssl::EC_KEY>,
+ _marker: PhantomData<C>,
+ }
+
+ impl<C: PCurve> EcKey<C> {
+ pub fn generate() -> Result<EcKey<C>, BoringError> {
+ let mut key = CHeapWrapper::default();
+ // EC_KEY_set_group only errors if there's already a group set
+ key.ec_key_set_group(&C::group()).unwrap();
+ key.ec_key_generate_key()?;
+ Ok(EcKey {
+ key,
+ _marker: PhantomData,
+ })
+ }
+
+ /// Creates an `EcKey` from a BoringSSL `EC_KEY`.
+ ///
+ /// `from_EC_KEY` validates that `key`'s curve is `C`.
+ ///
+ /// # Panics
+ ///
+ /// `from_EC_KEY` panics if `key`'s group is not set.
+ #[allow(non_snake_case)]
+ pub fn from_EC_KEY(key: CHeapWrapper<boringssl::EC_KEY>) -> Result<EcKey<C>, Error> {
+ // ec_key_get0_group returns the EC_KEY's internal group pointer,
+ // which is guaranteed to be set by the caller.
+ C::validate_group(key.ec_key_get0_group().unwrap())?;
+ Ok(EcKey {
+ key,
+ _marker: PhantomData,
+ })
+ }
+ }
+
+ impl<C: PCurve> BoringDerKey for EcKey<C> {
+ fn pkey_assign(&self, pkey: &mut CHeapWrapper<boringssl::EVP_PKEY>) {
+ pkey.evp_pkey_assign_ec_key(self.key.clone())
+ }
+
+ // NOTE: panics if the key is an EC key and doesn't have a group set
+ // (due to EcKey::from_EC_KEY)
+ fn pkey_get(pkey: &mut CHeapWrapper<boringssl::EVP_PKEY>) -> Result<Self, Error> {
+ let key = pkey.evp_pkey_get1_ec_key()?;
+ EcKey::from_EC_KEY(key)
+ }
+
+ fn parse_private_key(cbs: &mut CStackWrapper<boringssl::CBS>) -> Result<EcKey<C>, Error> {
+ // The last argument is a group. If it's not None, then it is either
+ // used as the group or, if the DER encoding also contains a group,
+ // the encoded group is validated against the group passed as an
+ // argument. Note that this validation is mostly redundant - similar
+ // validation is performed in EcKey::from_EC_KEY - however, it's not
+ // fully redundant, since it allows keys to be parsed which have no
+ // group.
+ let key = CHeapWrapper::ec_key_parse_private_key(cbs, Some(C::group()))?;
+ EcKey::from_EC_KEY(key)
+ }
+
+ fn marshal_private_key(
+ &self, cbb: &mut CStackWrapper<boringssl::CBB>,
+ ) -> Result<(), Error> {
+ self.key.ec_key_marshal_private_key(cbb).map_err(From::from)
+ }
+ }
+
+ #[cfg(test)]
+ mod tests {
+ use std::mem;
+
+ use super::*;
+ use public::ec::{P256, P384, P521};
+
+ #[test]
+ fn test_refcount() {
+ fn test<C: PCurve>() {
+ let key = EcKey::<C>::generate().unwrap();
+ for i in 0..8 {
+ // make i clones and then free them all
+ let mut keys = Vec::new();
+ for _ in 0..i {
+ keys.push(key.clone());
+ }
+ mem::drop(keys);
+ }
+ mem::drop(key);
+ }
+
+ test::<P256>();
+ test::<P384>();
+ test::<P521>();
+ }
+ }
+}
+
+/// An elliptic curve public key over a P curve.
+///
+/// `EcPubKey` is a public key over the curve `C`.
+pub struct EcPubKey<C: PCurve> {
+ inner: EcKey<C>,
+}
+
+impl<C: PCurve> Sealed for EcPubKey<C> {}
+impl<C: PCurve> DerPublicKey for EcPubKey<C> {}
+
+impl<C: PCurve> DerKey for EcPubKey<C> {
+ type Boring = EcKey<C>;
+ fn boring(&self) -> &EcKey<C> {
+ &self.inner
+ }
+ fn from_boring(inner: EcKey<C>) -> EcPubKey<C> {
+ EcPubKey { inner }
+ }
+}
+
+impl<C: PCurve> PublicKey for EcPubKey<C> {
+ type Private = EcPrivKey<C>;
+}
+
+impl<C: PCurve> Debug for EcPubKey<C> {
+ fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> {
+ write!(f, "EcPubKey")
+ }
+}
+
+/// An elliptic curve private key over a P curve.
+///
+/// `EcPrivKey` is a private key over the curve `C`.
+pub struct EcPrivKey<C: PCurve> {
+ inner: EcKey<C>,
+}
+
+impl<C: PCurve> EcPrivKey<C> {
+ /// Generates a new private key.
+ #[must_use]
+ pub fn generate() -> Result<EcPrivKey<C>, Error> {
+ Ok(EcPrivKey {
+ inner: EcKey::generate()?,
+ })
+ }
+}
+
+impl<C: PCurve> Sealed for EcPrivKey<C> {}
+impl<C: PCurve> DerPrivateKey for EcPrivKey<C> {}
+
+impl<C: PCurve> DerKey for EcPrivKey<C> {
+ type Boring = EcKey<C>;
+ fn boring(&self) -> &EcKey<C> {
+ &self.inner
+ }
+ fn from_boring(inner: EcKey<C>) -> EcPrivKey<C> {
+ EcPrivKey { inner }
+ }
+}
+
+impl<C: PCurve> PrivateKey for EcPrivKey<C> {
+ type Public = EcPubKey<C>;
+
+ fn public(&self) -> EcPubKey<C> {
+ EcPubKey {
+ inner: self.inner.clone(),
+ }
+ }
+}
+
+impl<C: PCurve> Debug for EcPrivKey<C> {
+ fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> {
+ write!(f, "EcPrivKey")
+ }
+}
+
+/// An elliptic curve public key whose curve is unknown at compile time.
+///
+/// An `EcPubKeyAnyCurve` is an enum of [`EcPubKey`]s over the three supported
+/// curves. It is returned from [`parse_public_key_der_any_curve`].
+#[allow(missing_docs)]
+#[derive(Debug)]
+pub enum EcPubKeyAnyCurve {
+ P256(EcPubKey<P256>),
+ P384(EcPubKey<P384>),
+ P521(EcPubKey<P521>),
+}
+
+/// An elliptic curve private key whose curve is unknown at compile time.
+///
+/// An `EcPrivKeyAnyCurve` is an enum of [`EcPrivKey`]s over the three supported
+/// curves. It is returned from [`parse_private_key_der_any_curve`].
+#[allow(missing_docs)]
+#[derive(Debug)]
+pub enum EcPrivKeyAnyCurve {
+ P256(EcPrivKey<P256>),
+ P384(EcPrivKey<P384>),
+ P521(EcPrivKey<P521>),
+}
+
+impl EcPrivKeyAnyCurve {
+ /// Gets the public key corresponding to this private key.
+ #[must_use]
+ pub fn public(&self) -> EcPubKeyAnyCurve {
+ match self {
+ EcPrivKeyAnyCurve::P256(key) => EcPubKeyAnyCurve::P256(key.public()),
+ EcPrivKeyAnyCurve::P384(key) => EcPubKeyAnyCurve::P384(key.public()),
+ EcPrivKeyAnyCurve::P521(key) => EcPubKeyAnyCurve::P521(key.public()),
+ }
+ }
+}
+
+/// Parses a public key in DER format with any curve.
+///
+/// `parse_public_key_der_any_curve` is like [`parse_public_key_der`], but it
+/// accepts any [`PCurve`] rather than a particular, static curve.
+///
+/// Since `parse_public_key_der` takes a [`PublicKey`] type argument, and
+/// [`EcPubKey`] requires a static [`PCurve`] type parameter,
+/// `parse_public_key_der` can only be called when the curve is known ahead of
+/// time. `parse_public_key_der_any_curve`, on the other hand, accepts any
+/// curve. It returns an [`EcPubKeyAnyCurve`], which is an enum of keys over the
+/// three supported curves.
+///
+/// Because the curve is not known statically, one must be specified in the DER
+/// input.
+///
+/// [`parse_public_key_der`]: ::public::parse_public_key_der
+/// [`PublicKey`]: ::public::PublicKey
+#[must_use]
+pub fn parse_public_key_der_any_curve(bytes: &[u8]) -> Result<EcPubKeyAnyCurve, Error> {
+ CStackWrapper::cbs_with_temp_buffer(bytes, |cbs| {
+ let mut evp_pkey = CHeapWrapper::evp_parse_public_key(cbs)?;
+ let key = evp_pkey.evp_pkey_get1_ec_key()?;
+ if cbs.cbs_len() > 0 {
+ return Err(Error::new("malformed DER input".to_string()));
+ }
+
+ // EVP_parse_public_key guarantees that the returned key has its group
+ // set, so this unwrap is safe.
+ let group = key.ec_key_get0_group().unwrap();
+ Ok(
+ match CurveKind::from_nid(group.ec_group_get_curve_name())? {
+ CurveKind::P256 => EcPubKeyAnyCurve::P256(EcPubKey {
+ inner: EcKey::from_EC_KEY(key.clone())?,
+ }),
+ CurveKind::P384 => EcPubKeyAnyCurve::P384(EcPubKey {
+ inner: EcKey::from_EC_KEY(key.clone())?,
+ }),
+ CurveKind::P521 => EcPubKeyAnyCurve::P521(EcPubKey {
+ inner: EcKey::from_EC_KEY(key.clone())?,
+ }),
+ },
+ )
+ })
+}
+
+/// Parses a private key in DER format with any curve.
+///
+/// `parse_private_key_der_any_curve` is like [`parse_private_key_der`], but it
+/// accepts any [`PCurve`] rather than a particular, static curve.
+///
+/// Since `parse_private_key_der` takes a [`PrivateKey`] type argument, and
+/// [`EcPrivKey`] requires a static [`PCurve`] type parameter,
+/// `parse_private_key_der` can only be called when the curve is known ahead of
+/// time. `parse_private_key_der_any_curve`, on the other hand, accepts any
+/// curve. It returns an [`EcPrivKeyAnyCurve`], which is an enum of keys over
+/// the three supported curves.
+///
+/// Because the curve is not known statically, one must be specified in the DER
+/// input.
+///
+/// [`parse_private_key_der`]: ::public::parse_private_key_der
+/// [`PrivateKey`]: ::public::PrivateKey
+#[must_use]
+pub fn parse_private_key_der_any_curve(bytes: &[u8]) -> Result<EcPrivKeyAnyCurve, Error> {
+ CStackWrapper::cbs_with_temp_buffer(bytes, |cbs| {
+ // The last argument is a group. Since it's None,
+ // EC_KEY_parse_private_key will require the DER to name the group.
+ let key = CHeapWrapper::ec_key_parse_private_key(cbs, None)?;
+ if cbs.cbs_len() > 0 {
+ return Err(Error::new("malformed DER input".to_string()));
+ }
+
+ // TODO(joshlf): Add documentation to EC_KEY_parse_private_key
+ // guaranteeing that the internal group pointer is set.
+ let group = key.ec_key_get0_group().unwrap();
+ Ok(
+ match CurveKind::from_nid(group.ec_group_get_curve_name())? {
+ CurveKind::P256 => EcPrivKeyAnyCurve::P256(EcPrivKey {
+ inner: EcKey::from_EC_KEY(key.clone())?,
+ }),
+ CurveKind::P384 => EcPrivKeyAnyCurve::P384(EcPrivKey {
+ inner: EcKey::from_EC_KEY(key.clone())?,
+ }),
+ CurveKind::P521 => EcPrivKeyAnyCurve::P521(EcPrivKey {
+ inner: EcKey::from_EC_KEY(key.clone())?,
+ }),
+ },
+ )
+ })
+}
+
+/// The Elliptic Curve Digital Signature Algorithm.
+pub mod ecdsa {
+ use std::fmt::{self, Debug, Formatter};
+ use std::marker::PhantomData;
+
+ use boringssl;
+ use hash::{inner::Digest, Hasher, Sha256, Sha384};
+ use public::{ec::{EcPrivKey, EcPubKey, PCurve, P256, P384, P521},
+ Signature};
+ use util::Sealed;
+ use Error;
+
+ /// A hash function which is compatible with ECDSA signatures over the curve
+ /// `C`.
+ ///
+ /// An ECDSA signature is constructed by hashing the message and then
+ /// signing the resulting digest. However, EC keys over certain curves may
+ /// not be compatible with all hashes. In particular, some digests may be
+ /// too long (in number of bytes) and thus not correspond to a point on the
+ /// curve. `EcdsaHash<C>` is implemented by all hash functions whose digests
+ /// are compatible with ECDSA signatures over the curve `C`.
+ pub trait EcdsaHash<C: PCurve>: Sealed {}
+
+ impl EcdsaHash<P256> for Sha256 {}
+ impl EcdsaHash<P384> for Sha256 {}
+ impl EcdsaHash<P384> for Sha384 {}
+ impl EcdsaHash<P521> for Sha256 {}
+ impl EcdsaHash<P521> for Sha384 {}
+
+ // The maximum length of an ECDSA signature over P-521. Since this isn't
+ // exposed in the API, we can increase later if we add support for curves
+ // with larger signatures.
+ //
+ // This was calculated with the following equation, which is thanks to
+ // agl@google.com:
+ //
+ // r = s = (521 + 7)/8 # Bytes to store the integers r and s
+ // = 66
+ // DER encoded bytes = (1 # type byte 0x02
+ // + 1 # length byte
+ // + 1 # possible 0 padding
+ // + 66) * 2 # one for each of r and s
+ // + 1 # ASN.1 SEQUENCE type byte
+ // + 2 # outer length
+ // = 141
+ const MAX_SIGNATURE_LEN: usize = 141;
+
+ /// A DER-encoded ECDSA signature.
+ #[must_use]
+ pub struct EcdsaSignature<C: PCurve, H: Hasher + EcdsaHash<C>> {
+ bytes: [u8; MAX_SIGNATURE_LEN],
+ // Invariant: len is in [0; MAX_SIGNATURE_LEN). If len is 0, it
+ // indicates an invalid signature. Invalid signatures can be produced
+ // when a caller invokes from_bytes with a byte slice longer than
+ // MAX_SIGNATURE_LEN. Such signatures cannot possibly have been
+ // generated by an ECDSA signature over any of the curves we support,
+ // and so it could not possibly be valid. In other words, it would never
+ // be correct for ecdsa_verify to return true when invoked on such a
+ // signature.
+ //
+ // However, if we were to simply truncate the byte slice and store a
+ // subset of it, then we might open ourselves up to attacks in which an
+ // attacker induces a mismatch between the signature that the caller
+ // /thinks/ is being verified and the signature that is /actually/ being
+ // verified. Thus, it's important that we always reject such signatures.
+ //
+ // Finally, it's OK for us to use 0 as the sentinal value to mean
+ // "invalid signature" because ECDSA can never produce a 0-byte
+ // signature. Thus, we will never produce a 0-byte signature from
+ // ecdsa_sign, and similarly, if the caller constructs a 0-byte
+ // signature using from_bytes, it's correct for us to treat it as
+ // invalid.
+ len: usize,
+ _marker: PhantomData<(C, H)>,
+ }
+
+ impl<C: PCurve, H: Hasher + EcdsaHash<C>> EcdsaSignature<C, H> {
+ /// Constructs an `EcdsaSignature` from raw bytes.
+ #[must_use]
+ pub fn from_bytes(bytes: &[u8]) -> EcdsaSignature<C, H> {
+ if bytes.len() > MAX_SIGNATURE_LEN {
+ // see comment on the len field for why we do this
+ return Self::empty();
+ }
+ let mut ret = Self::empty();
+ (&mut ret.bytes[..bytes.len()]).copy_from_slice(bytes);
+ ret.len = bytes.len();
+ ret
+ }
+
+ // TODO(joshlf): Once we have const generics, have this return a
+ // fixed-length array.
+
+ /// Gets the raw bytes of this `EcdsaSignature`.
+ #[must_use]
+ pub fn bytes(&self) -> &[u8] {
+ &self.bytes[..self.len]
+ }
+
+ fn is_valid(&self) -> bool {
+ self.len != 0
+ }
+
+ fn empty() -> EcdsaSignature<C, H> {
+ EcdsaSignature {
+ bytes: [0u8; MAX_SIGNATURE_LEN],
+ len: 0,
+ _marker: PhantomData,
+ }
+ }
+ }
+
+ impl<C: PCurve, H: Hasher + EcdsaHash<C>> Sealed for EcdsaSignature<C, H> {}
+ impl<C: PCurve, H: Hasher + EcdsaHash<C>> Signature for EcdsaSignature<C, H> {
+ type PrivateKey = EcPrivKey<C>;
+
+ fn sign(key: &EcPrivKey<C>, message: &[u8]) -> Result<EcdsaSignature<C, H>, Error> {
+ let digest = H::hash(message);
+ let mut sig = EcdsaSignature::empty();
+ sig.len = boringssl::ecdsa_sign(digest.as_ref(), &mut sig.bytes[..], &key.inner.key)?;
+ Ok(sig)
+ }
+
+ fn verify(&self, key: &EcPubKey<C>, message: &[u8]) -> bool {
+ if !self.is_valid() {
+ // see comment on EcdsaSignature::len for why we do this
+ return false;
+ }
+ let digest = H::hash(message);
+ boringssl::ecdsa_verify(digest.as_ref(), self.bytes(), &key.inner.key)
+ }
+ }
+
+ impl<C: PCurve, H: Hasher + EcdsaHash<C>> Debug for EcdsaSignature<C, H> {
+ fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> {
+ write!(f, "EcdsaSignature")
+ }
+ }
+
+ #[cfg(test)]
+ mod tests {
+ use super::{super::*, *};
+ use public::testutil::test_signature_smoke;
+
+ #[test]
+ fn test_smoke() {
+ let p256 = EcPrivKey::<P256>::generate().unwrap();
+ let p384 = EcPrivKey::<P384>::generate().unwrap();
+ let p521 = EcPrivKey::<P521>::generate().unwrap();
+
+ test_signature_smoke(
+ &p256,
+ EcdsaSignature::<_, Sha256>::from_bytes,
+ EcdsaSignature::bytes,
+ );
+ test_signature_smoke(
+ &p384,
+ EcdsaSignature::<_, Sha256>::from_bytes,
+ EcdsaSignature::bytes,
+ );
+ test_signature_smoke(
+ &p384,
+ EcdsaSignature::<_, Sha384>::from_bytes,
+ EcdsaSignature::bytes,
+ );
+ test_signature_smoke(
+ &p521,
+ EcdsaSignature::<_, Sha256>::from_bytes,
+ EcdsaSignature::bytes,
+ );
+ test_signature_smoke(
+ &p521,
+ EcdsaSignature::<_, Sha384>::from_bytes,
+ EcdsaSignature::bytes,
+ );
+ }
+
+ #[test]
+ fn test_invalid_signature() {
+ fn test_is_invalid(sig: &EcdsaSignature<P256, Sha256>) {
+ assert_eq!(sig.len, 0);
+ assert!(!sig.is_valid());
+ assert!(!sig.verify(&EcPrivKey::<P256>::generate().unwrap().public(), &[],));
+ }
+ test_is_invalid(&EcdsaSignature::from_bytes(&[0; MAX_SIGNATURE_LEN + 1]));
+ test_is_invalid(&EcdsaSignature::from_bytes(&[]));
+ }
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use hash::Sha256;
+ use public::ec::ecdsa::*;
+ use public::{marshal_private_key_der, marshal_public_key_der, parse_private_key_der,
+ parse_public_key_der, Signature};
+ use util::should_fail;
+
+ #[test]
+ fn test_generate() {
+ EcPrivKey::<P256>::generate().unwrap();
+ EcPrivKey::<P384>::generate().unwrap();
+ EcPrivKey::<P521>::generate().unwrap();
+ }
+
+ #[test]
+ fn test_marshal_parse() {
+ // Test various combinations of parsing and serializing keys.
+ //
+ // Since we need to test dynamic parsing (the
+ // parse_private_key_der_any_curve and parse_public_key_der_any_curve
+ // functions), we need a way of unwrapping their return values into a
+ // static key type. Unfortunately, there's no way (on stable Rust) to do
+ // that generically, so the caller must pass a function which will do
+ // it.
+ fn test<
+ C: PCurve,
+ F: Fn(EcPrivKeyAnyCurve) -> EcPrivKey<C>,
+ G: Fn(EcPubKeyAnyCurve) -> EcPubKey<C>,
+ >(
+ unwrap_priv_any: F, unwrap_pub_any: G,
+ ) where
+ Sha256: EcdsaHash<C>,
+ {
+ const MESSAGE: &[u8] = &[0, 1, 2, 3, 4, 5, 6, 7];
+ let key = EcPrivKey::<C>::generate().unwrap();
+
+ let parsed_key: EcPrivKey<C> =
+ parse_private_key_der(&marshal_private_key_der(&key)).unwrap();
+ let parsed_key_any_curve = unwrap_priv_any(
+ parse_private_key_der_any_curve(&marshal_private_key_der(&key)).unwrap(),
+ );
+ let pubkey = key.public();
+ let parsed_pubkey: EcPubKey<C> =
+ parse_public_key_der(&marshal_public_key_der(&pubkey)).unwrap();
+ let parsed_pubkey_any_curve = unwrap_pub_any(
+ parse_public_key_der_any_curve(&marshal_public_key_der(&pubkey)).unwrap(),
+ );
+
+ fn sign_and_verify<C1: PCurve, C2: PCurve>(
+ privkey: &EcPrivKey<C1>, pubkey: &EcPubKey<C2>,
+ ) where
+ Sha256: EcdsaHash<C1>,
+ Sha256: EcdsaHash<C2>,
+ {
+ let sig = EcdsaSignature::<C1, Sha256>::sign(&privkey, MESSAGE).unwrap();
+ assert!(
+ EcdsaSignature::<C2, Sha256>::from_bytes(sig.bytes()).verify(&pubkey, MESSAGE)
+ )
+ }
+
+ // Sign and verify with every pair of keys to make sure we parsed
+ // the same key we marshaled.
+ sign_and_verify(&key, &pubkey);
+ sign_and_verify(&key, &parsed_pubkey);
+ sign_and_verify(&key, &parsed_pubkey_any_curve);
+ sign_and_verify(&parsed_key, &pubkey);
+ sign_and_verify(&parsed_key, &parsed_pubkey);
+ sign_and_verify(&parsed_key, &parsed_pubkey_any_curve);
+ sign_and_verify(&parsed_key_any_curve, &pubkey);
+ sign_and_verify(&parsed_key_any_curve, &parsed_pubkey);
+ sign_and_verify(&parsed_key_any_curve, &parsed_pubkey_any_curve);
+
+ let _ = marshal_public_key_der::<EcPubKey<C>>;
+ let _ = parse_public_key_der::<EcPubKey<C>>;
+ }
+
+ macro_rules! unwrap_any_curve {
+ ($name:ident, $any_type:ty, $key_type:ty, $curve_variant:path) => {
+ fn $name(key: $any_type) -> $key_type {
+ match key {
+ $curve_variant(key) => key,
+ _ => panic!("unexpected curve"),
+ }
+ }
+ };
+ }
+
+ unwrap_any_curve!(
+ unwrap_priv_key_any_p256,
+ EcPrivKeyAnyCurve,
+ EcPrivKey<P256>,
+ EcPrivKeyAnyCurve::P256
+ );
+ unwrap_any_curve!(
+ unwrap_priv_key_any_p384,
+ EcPrivKeyAnyCurve,
+ EcPrivKey<P384>,
+ EcPrivKeyAnyCurve::P384
+ );
+ unwrap_any_curve!(
+ unwrap_priv_key_any_p521,
+ EcPrivKeyAnyCurve,
+ EcPrivKey<P521>,
+ EcPrivKeyAnyCurve::P521
+ );
+ unwrap_any_curve!(
+ unwrap_pub_key_any_p256,
+ EcPubKeyAnyCurve,
+ EcPubKey<P256>,
+ EcPubKeyAnyCurve::P256
+ );
+ unwrap_any_curve!(
+ unwrap_pub_key_any_p384,
+ EcPubKeyAnyCurve,
+ EcPubKey<P384>,
+ EcPubKeyAnyCurve::P384
+ );
+ unwrap_any_curve!(
+ unwrap_pub_key_any_p521,
+ EcPubKeyAnyCurve,
+ EcPubKey<P521>,
+ EcPubKeyAnyCurve::P521
+ );
+
+ test::<P256, _, _>(unwrap_priv_key_any_p256, unwrap_pub_key_any_p256);
+ test::<P384, _, _>(unwrap_priv_key_any_p384, unwrap_pub_key_any_p384);
+ test::<P521, _, _>(unwrap_priv_key_any_p521, unwrap_pub_key_any_p521);
+ }
+
+ #[test]
+ fn test_parse_fail() {
+ // Test that invalid input is rejected.
+ fn test_parse_invalid<C: PCurve>() {
+ should_fail(
+ parse_private_key_der::<EcPrivKey<C>>(&[]),
+ "parse_private_key_der",
+ "elliptic curve routines:OPENSSL_internal:DECODE_ERROR",
+ );
+ should_fail(
+ parse_public_key_der::<EcPubKey<C>>(&[]),
+ "parse_public_key_der",
+ "public key routines:OPENSSL_internal:DECODE_ERROR",
+ );
+ should_fail(
+ parse_private_key_der_any_curve(&[]),
+ "parse_private_key_der_any_curve",
+ "elliptic curve routines:OPENSSL_internal:DECODE_ERROR",
+ );
+ should_fail(
+ parse_public_key_der_any_curve(&[]),
+ "parse_public_key_der_any_curve",
+ "public key routines:OPENSSL_internal:DECODE_ERROR",
+ );
+ }
+
+ test_parse_invalid::<P256>();
+ test_parse_invalid::<P384>();
+ test_parse_invalid::<P521>();
+
+ // Test that, when a particular curve is expected, other curves are
+ // rejected.
+ fn test_parse_wrong_curve<C1: PCurve, C2: PCurve>() {
+ let privkey = EcPrivKey::<C1>::generate().unwrap();
+ let key_der = marshal_private_key_der(&privkey);
+ should_fail(
+ parse_private_key_der::<EcPrivKey<C2>>(&key_der),
+ "parse_private_key_der",
+ "elliptic curve routines:OPENSSL_internal:GROUP_MISMATCH",
+ );
+ let key_der = marshal_public_key_der(&privkey.public());
+ should_fail(
+ parse_public_key_der::<EcPubKey<C2>>(&key_der),
+ "parse_public_key_der",
+ "mundane: unexpected curve:",
+ );
+ }
+
+ // All pairs of curves, (X, Y), such that X != Y.
+ test_parse_wrong_curve::<P256, P384>();
+ test_parse_wrong_curve::<P256, P521>();
+ test_parse_wrong_curve::<P384, P256>();
+ test_parse_wrong_curve::<P384, P521>();
+ test_parse_wrong_curve::<P521, P256>();
+ test_parse_wrong_curve::<P521, P384>();
+ }
+}
diff --git a/src/public/ed25519.rs b/src/public/ed25519.rs
new file mode 100644
index 0000000..21bf3ea
--- /dev/null
+++ b/src/public/ed25519.rs
@@ -0,0 +1,212 @@
+// Copyright 2018 Google LLC
+//
+// Use of this source code is governed by an MIT-style
+// license that can be found in the LICENSE file or at
+// https://opensource.org/licenses/MIT.
+
+//! The Ed25519 signature algorithm.
+
+use boringssl::{ed25519_keypair, ed25519_keypair_from_seed, ed25519_sign, ed25519_verify};
+use public::{PrivateKey, PublicKey, Signature};
+use util::Sealed;
+use Error;
+
+const ED25519_PUBLIC_KEY_LEN: usize = ::boringssl::ED25519_PUBLIC_KEY_LEN as usize;
+const ED25519_PRIVATE_KEY_LEN: usize = ::boringssl::ED25519_PRIVATE_KEY_LEN as usize;
+const ED25519_SIGNATURE_LEN: usize = ::boringssl::ED25519_SIGNATURE_LEN as usize;
+// BoringSSL stores both a private and a public key in their private key
+// representation. The private key comes first, followed by the public key.
+const ED25519_PUBLIC_KEY_OFFSET: usize = ED25519_PRIVATE_KEY_LEN - ED25519_PUBLIC_KEY_LEN;
+
+/// An Ed25519 public key.
+pub struct Ed25519PubKey {
+ key: [u8; ED25519_PUBLIC_KEY_LEN],
+}
+
+impl Ed25519PubKey {
+ /// Constructs a new public key from bytes.
+ #[must_use]
+ pub fn from_bytes(bytes: [u8; ED25519_PUBLIC_KEY_LEN]) -> Ed25519PubKey {
+ Ed25519PubKey { key: bytes }
+ }
+
+ /// Gets the raw bytes of the public key.
+ #[must_use]
+ pub fn bytes(&self) -> &[u8; ED25519_PUBLIC_KEY_LEN] {
+ &self.key
+ }
+}
+
+impl_debug!(Ed25519PubKey, "Ed25519PubKey");
+
+impl Sealed for Ed25519PubKey {}
+impl PublicKey for Ed25519PubKey {
+ type Private = Ed25519PrivKey;
+}
+
+/// An Ed25519 private key.
+///
+/// An `Ed25519PrivKey` actually includes both the private key and the public
+/// key in order to make multiple key signing operations with the same key more
+/// efficient.
+pub struct Ed25519PrivKey {
+ key: [u8; ED25519_PRIVATE_KEY_LEN],
+}
+
+impl_debug!(Ed25519PrivKey, "Ed25519PrivKey");
+
+impl Ed25519PrivKey {
+ /// Generates a new private key.
+ #[must_use]
+ pub fn generate() -> Ed25519PrivKey {
+ Ed25519PrivKey {
+ key: ed25519_keypair(),
+ }
+ }
+
+ /// Constructs a new private key from a key pair.
+ ///
+ /// Usually, an Ed25519 private key will be stored as a single 64-byte blob:
+ /// the 32-byte private key followed by the 32-byte public key. However, we
+ /// accept the two keys as separate arguments in case they are stored
+ /// separately.
+ #[must_use]
+ pub fn from_key_pair_bytes(private: [u8; 32], public: &Ed25519PubKey) -> Ed25519PrivKey {
+ let mut key = [0u8; ED25519_PRIVATE_KEY_LEN];
+ (&mut key[..32]).copy_from_slice(&private);
+ (&mut key[ED25519_PUBLIC_KEY_OFFSET..]).copy_from_slice(&public.key);
+ Ed25519PrivKey { key }
+ }
+
+ /// Constructs a new private key.
+ ///
+ /// Unlike [`from_key_pair_bytes`], `from_private_key_bytes` reconstructs
+ /// the key (which includes both the private key and the public key
+ /// internally) from only the private key.
+ ///
+ /// [`from_key_pair_bytes`]: ::public::ed25519::Ed25519PrivKey::from_key_pair_bytes
+ #[must_use]
+ pub fn from_private_key_bytes(private: [u8; 32]) -> Ed25519PrivKey {
+ let (_, key) = ed25519_keypair_from_seed(&private);
+ Ed25519PrivKey { key }
+ }
+
+ /// Gets the raw bytes of the private key.
+ #[must_use]
+ pub fn bytes(&self) -> &[u8; ED25519_PRIVATE_KEY_LEN] {
+ &self.key
+ }
+}
+
+impl Sealed for Ed25519PrivKey {}
+impl PrivateKey for Ed25519PrivKey {
+ type Public = Ed25519PubKey;
+
+ fn public(&self) -> Ed25519PubKey {
+ let mut public = [0u8; ED25519_PUBLIC_KEY_LEN];
+ (&mut public[..]).copy_from_slice(&self.key[ED25519_PUBLIC_KEY_OFFSET..]);
+ Ed25519PubKey { key: public }
+ }
+}
+
+/// An Ed25519 signature.
+#[must_use]
+pub struct Ed25519Signature {
+ sig: [u8; ED25519_SIGNATURE_LEN],
+}
+
+impl_debug!(Ed25519Signature, "Ed25519Signature");
+
+impl Ed25519Signature {
+ /// Constructs an `Ed25519Signature` signature from raw bytes.
+ #[must_use]
+ pub fn from_bytes(bytes: [u8; ED25519_SIGNATURE_LEN]) -> Ed25519Signature {
+ Ed25519Signature { sig: bytes }
+ }
+
+ /// Gets the raw bytes of the signature.
+ #[must_use]
+ pub fn bytes(&self) -> &[u8; ED25519_SIGNATURE_LEN] {
+ &self.sig
+ }
+
+ /// Sign a message.
+ ///
+ /// `Ed25519Signature` implements [`Signature`], but `Signature`'s [`sign`]
+ /// function conservatively returns a `Result`. Ed25519 signatures never
+ /// fail, so this function is provided to allow the user to compute an
+ /// Ed25519 signature without having to perform error checking.
+ ///
+ /// [`Signature`]: ::public::Signature
+ /// [`sign`]: ::public::Signature::sign
+ #[must_use]
+ pub fn sign_ed25519(key: &Ed25519PrivKey, message: &[u8]) -> Ed25519Signature {
+ Ed25519Signature {
+ // ED25519_sign can only return an error on OOM
+ sig: ed25519_sign(message, &key.key).unwrap(),
+ }
+ }
+}
+
+impl Sealed for Ed25519Signature {}
+impl Signature for Ed25519Signature {
+ type PrivateKey = Ed25519PrivKey;
+
+ /// Sign a message.
+ ///
+ /// Though the [`Signature`] trait requires that [`sign`] return a `Result`,
+ /// `Ed25519Signature`'s implementation is guaranteed to always return `Ok`.
+ /// Callers may prefer the [`sign_ed25519`] function, which returns an
+ /// `Ed25519Signature` rather than a `Result`.
+ ///
+ /// [`Signature`]: ::public::Signature
+ /// [`sign`]: ::public::Signature::sign
+ /// [`sign_ed25519`]: ::public::ed25519::Ed25519Signature::sign_ed25519
+ fn sign(key: &Ed25519PrivKey, message: &[u8]) -> Result<Ed25519Signature, Error> {
+ Ok(Ed25519Signature::sign_ed25519(key, message))
+ }
+
+ fn verify(&self, key: &Ed25519PubKey, message: &[u8]) -> bool {
+ ed25519_verify(message, &self.sig, &key.key)
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use public::testutil::test_signature_smoke;
+
+ #[test]
+ fn test_priv_key_constructors() {
+ let key = Ed25519PrivKey::generate();
+ let mut private = [0u8; 32];
+ (&mut private[..]).copy_from_slice(&key.key[..32]);
+ let key2 = Ed25519PrivKey::from_private_key_bytes(private);
+ assert_eq!(&key.key[..], &key2.key[..]);
+
+ let mut private = [0u8; 32];
+ let mut public = [0u8; 32];
+ let bytes = *key.bytes();
+ (&mut private[..]).copy_from_slice(&bytes[..32]);
+ (&mut public[..]).copy_from_slice(&bytes[32..]);
+ let key2 = Ed25519PrivKey::from_key_pair_bytes(private, &Ed25519PubKey::from_bytes(public));
+ assert_eq!(&key.key[..], &key2.key[..]);
+ }
+
+ #[test]
+ fn test_smoke() {
+ let key = Ed25519PrivKey::generate();
+ let from_bytes = |bytes: &[u8]| {
+ let mut sig = [0u8; ED25519_SIGNATURE_LEN];
+ let len = ::std::cmp::min(sig.len(), bytes.len());
+ (&mut sig[..len]).copy_from_slice(&bytes[..len]);
+ Ed25519Signature::from_bytes(sig)
+ };
+ // for some reason, defining this as a closure results in type inference
+ // issues that aren't worth debugging
+ fn to_bytes(sig: &Ed25519Signature) -> &[u8] {
+ &sig.bytes()[..]
+ }
+ test_signature_smoke(&key, from_bytes, to_bytes);
+ }
+}
diff --git a/src/public/mod.rs b/src/public/mod.rs
new file mode 100644
index 0000000..26dc754
--- /dev/null
+++ b/src/public/mod.rs
@@ -0,0 +1,226 @@
+// Copyright 2018 Google LLC
+//
+// Use of this source code is governed by an MIT-style
+// license that can be found in the LICENSE file or at
+// https://opensource.org/licenses/MIT.
+
+//! Public key cryptography.
+
+pub mod ec;
+pub mod ed25519;
+
+use boringssl::{CHeapWrapper, CStackWrapper};
+use public::inner::BoringDerKey;
+use util::Sealed;
+use Error;
+
+/// The public component of a public/private key pair.
+pub trait PublicKey: Sealed + Sized {
+ /// The type of the private component.
+ type Private: PrivateKey<Public = Self>;
+}
+
+/// The private component of a public/private key pair.
+pub trait PrivateKey: Sealed + Sized {
+ /// The type of the public component.
+ type Public: PublicKey<Private = Self>;
+
+ /// Gets the public key corresponding to this private key.
+ #[must_use]
+ fn public(&self) -> Self::Public;
+}
+
+/// A public key which can be encoded as a DER object.
+pub trait DerPublicKey: PublicKey + self::inner::DerKey {}
+
+/// A private key which can be encoded as a DER object.
+pub trait DerPrivateKey: PrivateKey + self::inner::DerKey {}
+
+/// A cryptographic signature generated by a private key.
+pub trait Signature: Sealed + Sized {
+ /// The private key type used to generate this signature.
+ type PrivateKey: PrivateKey;
+
+ /// Sign a message.
+ ///
+ /// The input to this function is always a message, never a digest. If a
+ /// signature scheme calls for hashing a message and signing the hash
+ /// digest, `sign` is responsible for both hashing and signing.
+ #[must_use]
+ fn sign(key: &Self::PrivateKey, message: &[u8]) -> Result<Self, Error>;
+
+ /// Verify a signature.
+ ///
+ /// The input to this function is always a message, never a digest. If a
+ /// signature scheme calls for hashing a message and signing the hash
+ /// digest, `verify` is responsible for both hashing and verifying the
+ /// digest.
+ #[must_use]
+ fn verify(&self, key: &<Self::PrivateKey as PrivateKey>::Public, message: &[u8]) -> bool;
+}
+
+mod inner {
+ use boringssl::{self, CHeapWrapper, CStackWrapper};
+ use Error;
+
+ /// A wrapper around a BoringSSL key object.
+ pub trait BoringDerKey: Sized {
+ // evp_pkey_assign_xxx
+ fn pkey_assign(&self, pkey: &mut CHeapWrapper<boringssl::EVP_PKEY>);
+
+ // evp_pkey_get_xxx; panics if the key is an EC key and doesn't have a group set,
+ // and errors if pkey isn't the expected key type
+ fn pkey_get(pkey: &mut CHeapWrapper<boringssl::EVP_PKEY>) -> Result<Self, Error>;
+
+ // xxx_parse_private_key
+ fn parse_private_key(cbs: &mut CStackWrapper<boringssl::CBS>) -> Result<Self, Error>;
+
+ // xxx_marshal_private_key
+ fn marshal_private_key(&self, cbb: &mut CStackWrapper<boringssl::CBB>)
+ -> Result<(), Error>;
+ }
+
+ /// Properties shared by both public and private keys of a given type.
+ pub trait DerKey {
+ /// The underlying BoringSSL object wrapper type.
+ type Boring: BoringDerKey;
+
+ fn boring(&self) -> &Self::Boring;
+
+ fn from_boring(Self::Boring) -> Self;
+ }
+}
+
+/// Marshals a public key in DER format.
+///
+/// `marshal_public_key_der` marshals a public key as a DER-encoded
+/// SubjectPublicKeyInfo structure as defined in [RFC 5280].
+///
+/// [RFC 5280]: https://tools.ietf.org/html/rfc5280
+#[must_use]
+pub fn marshal_public_key_der<P: DerPublicKey>(key: &P) -> Vec<u8> {
+ let mut evp_pkey = CHeapWrapper::default();
+ key.boring().pkey_assign(&mut evp_pkey);
+ // cbb_new can only fail due to OOM
+ let mut cbb = CStackWrapper::cbb_new(64).unwrap();
+ evp_pkey
+ .evp_marshal_public_key(&mut cbb)
+ .expect("failed to marshal public key");
+ cbb.cbb_with_data(<[u8]>::to_vec)
+}
+
+/// Marshals a private key in DER format.
+///
+/// `marshal_private_key_der` marshal a private key as a DER-encoded structure.
+/// The exact structure encoded depends on the type of key:
+/// - For an EC key, it is an ECPrivateKey structure as defined in [RFC 5915].
+/// - For an RSA key, it is an RSAPrivateKey structure as defined in [RFC 3447].
+///
+/// [RFC 5915]: https://tools.ietf.org/html/rfc5915
+/// [RFC 3447]: https://tools.ietf.org/html/rfc3447
+#[must_use]
+pub fn marshal_private_key_der<P: DerPrivateKey>(key: &P) -> Vec<u8> {
+ // cbb_new can only fail due to OOM
+ let mut cbb = CStackWrapper::cbb_new(64).unwrap();
+ key.boring()
+ .marshal_private_key(&mut cbb)
+ .expect("failed to marshal private key");
+ cbb.cbb_with_data(<[u8]>::to_vec)
+}
+
+/// Parses a public key in DER format.
+///
+/// `parse_public_key_der` parses a public key from a DER-encoded
+/// SubjectPublicKeyInfo structure as defined in [RFC 5280].
+///
+/// # Elliptic Curve Keys
+///
+/// For Elliptic Curve keys ([`EcPubKey`]), the curve itself is validated. If
+/// the curve is not known ahead of time, and any curve must be supported at
+/// runtime, use the [`parse_public_key_der_any_curve`] function.
+///
+/// [RFC 5280]: https://tools.ietf.org/html/rfc5280
+/// [`EcPubKey`]: ::public::ec::EcPubKey
+/// [`parse_public_key_der_any_curve`]: ::public::ec::parse_public_key_der_any_curve
+#[must_use]
+pub fn parse_public_key_der<P: DerPublicKey>(bytes: &[u8]) -> Result<P, Error> {
+ CStackWrapper::cbs_with_temp_buffer(bytes, |cbs| {
+ let mut evp_pkey = CHeapWrapper::evp_parse_public_key(cbs)?;
+ // NOTE: For EC, panics if evp_pkey doesn't have its group set. This is
+ // OK because EVP_parse_public_key guarantees that the returned key has
+ // its group set.
+ let key = P::Boring::pkey_get(&mut evp_pkey)?;
+ if cbs.cbs_len() > 0 {
+ return Err(Error::new("malformed DER input".to_string()));
+ }
+ Ok(P::from_boring(key))
+ })
+}
+
+/// Parses a private key in DER format.
+///
+/// `parse_private_key_der` parses a private key from a DER-encoded format. The
+/// exact structure expected depends on the type of key:
+/// - For an EC key, it is an ECPrivateKey structure as defined in [RFC 5915].
+/// - For an RSA key, it is an RSAPrivateKey structure as defined in [RFC 3447].
+///
+/// # Elliptic Curve Keys
+///
+/// For Elliptic Curve keys ([`EcPrivKey`]), the curve itself is validated. If
+/// the curve is not known ahead of time, and any curve must be supported at
+/// runtime, use the [`parse_private_key_der_any_curve`] function.
+///
+/// [RFC 5915]: https://tools.ietf.org/html/rfc5915
+/// [RFC 3447]: https://tools.ietf.org/html/rfc3447
+/// [`EcPrivKey`]: ::public::ec::EcPrivKey
+/// [`parse_private_key_der_any_curve`]: ::public::ec::parse_private_key_der_any_curve
+#[must_use]
+pub fn parse_private_key_der<P: DerPrivateKey>(bytes: &[u8]) -> Result<P, Error> {
+ CStackWrapper::cbs_with_temp_buffer(bytes, |cbs| {
+ let key = P::Boring::parse_private_key(cbs)?;
+ if cbs.cbs_len() > 0 {
+ return Err(Error::new("malformed DER input".to_string()));
+ }
+ Ok(P::from_boring(key))
+ })
+}
+
+#[cfg(test)]
+mod testutil {
+ use super::*;
+
+ /// Smoke test a signature scheme.
+ ///
+ /// `sig_from_bytes` takes a byte slice and converts it into a signature. If
+ /// the byte slice is too long, it either truncate it or treats it as
+ /// invalid (it's up to the caller). If the byte slice is too short, it
+ /// fills in the remaining bytes with zeroes.
+ pub fn test_signature_smoke<S: Signature, F: Fn(&[u8]) -> S, G: Fn(&S) -> &[u8]>(
+ key: &S::PrivateKey, sig_from_bytes: F, bytes_from_sig: G,
+ ) {
+ // Sign the message, verify the signature, and return the signature.
+ // Also verify that, if the wrong signature is used, the signature fails
+ // to verify. Also verify that sig_from_bytes works.
+ fn sign_and_verify<S: Signature, F: Fn(&[u8]) -> S, G: Fn(&S) -> &[u8]>(
+ key: &S::PrivateKey, message: &[u8], sig_from_bytes: F, bytes_from_sig: G,
+ ) -> S {
+ let sig = S::sign(key, message).unwrap();
+ assert!(sig.verify(&key.public(), message));
+ let sig2 = S::sign(&key, bytes_from_sig(&sig)).unwrap();
+ assert!(!sig2.verify(&key.public(), message));
+ sig_from_bytes(bytes_from_sig(&sig))
+ }
+
+ // Sign an empty message, and verify the signature. Use the signature as
+ // the next message to test, and repeat many times.
+ let mut msg = Vec::new();
+ for _ in 0..16 {
+ msg = bytes_from_sig(&sign_and_verify(
+ key,
+ &msg,
+ &sig_from_bytes,
+ &bytes_from_sig,
+ )).to_vec();
+ }
+ }
+}
diff --git a/src/util.rs b/src/util.rs
new file mode 100644
index 0000000..b9bb0e7
--- /dev/null
+++ b/src/util.rs
@@ -0,0 +1,37 @@
+// Copyright 2018 Google LLC
+//
+// Use of this source code is governed by an MIT-style
+// license that can be found in the LICENSE file or at
+// https://opensource.org/licenses/MIT.
+
+/// A trait that can be used to ensure that users of this crate can't implement
+/// a trait.
+///
+/// See the [API Guidelines] for details.
+///
+/// [API Guidelines]: https://rust-lang-nursery.github.io/api-guidelines/future-proofing.html#sealed-traits-protect-against-downstream-implementations-c-sealed
+pub trait Sealed {}
+
+/// Expects that a `Result` is an error.
+///
+/// `should_fail` ensures that `result` is an error, and that the error's
+/// `Debug` representation contains the string `expected_substr`. Otherwise, it
+/// panics.
+#[cfg(test)]
+pub fn should_fail<O, E: ::std::fmt::Debug>(
+ result: Result<O, E>, desc: &str, expected_substr: &str,
+) {
+ // Credit to agl@google.com for this implementation.
+ match result {
+ Ok(_) => panic!("{} unexpectedly succeeded", desc),
+ Err(err) => {
+ let err_str = format!("{:?}", err);
+ err_str.find(expected_substr).unwrap_or_else(|| {
+ panic!(
+ "{} resulted in error that doesn't include {:?}: {:?}",
+ desc, expected_substr, err_str
+ )
+ });
+ }
+ }
+}
