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, &params);
+                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
+                )
+            });
+        }
+    }
+}