Initial commit
diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..53eaa21 --- /dev/null +++ b/.gitignore
@@ -0,0 +1,2 @@ +/target +**/*.rs.bk
diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..ad2597c --- /dev/null +++ b/.gitmodules
@@ -0,0 +1,3 @@ +[submodule "boringssl/boringssl"] + path = boringssl/boringssl + url = https://boringssl.googlesource.com/boringssl
diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 index 0000000..b572595 --- /dev/null +++ b/CHANGELOG.md
@@ -0,0 +1,13 @@ +<!-- Copyright 2018 Google LLC + +Use of this source code is governed by an MIT-style +license that can be found in the LICENSE file or at +https://opensource.org/licenses/MIT. --> + +# Changelog + +All notable changes to this project will be documented in this file. + +The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/). + +## [Unreleased]
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md new file mode 100644 index 0000000..e06004a --- /dev/null +++ b/CONTRIBUTING.md
@@ -0,0 +1,193 @@ +<!-- Copyright 2018 Google LLC + +Use of this source code is governed by an MIT-style +license that can be found in the LICENSE file or at +https://opensource.org/licenses/MIT. --> + +# Contributing + +## Code Guidelines + +### Unsafe + +`unsafe` is not allowed, except for in the `boringssl` module. We +`#[forbid(unsafe)]` in all other modules, so code that uses `unsafe` outside of +that module should fail to compile. For details on how to use `unsafe` in the +`boringssl` module, see the doc comment on that module. + +### `#[must_use]` + +The `#[must_use]` directive causes the compiler to emit a warning if code calls +a function but does not use its return value. It is a very useful lint against +failing to properly act on the result of cryptographic operations. A +`#[must_use]` directive should go on: +- All functions/methods (including in trait definitions) which return a value + and are visible outside of the crate +- In the `boringssl` module: + - All functions/methods (including in trait definitions) which return a value + and are visible outside of the `boringssl` module or are exported from the + `raw` or `wrapper` modules to the top-level `boringssl` module + +`#[must_use]` may also be used on types, but should be evaluated on a +case-by-case basis. A few things to keep in mind: +- All functions defined in `mundane` which return values have `#[must_use]` on + them, so the case of a type returned by a function defined in `mundane` is + already covered. +- Unlike on functions, `#[must_use]` on types affects code other than the + immediate caller since code outside of this crate may return types which are + defined in this crate. + +Thus, `#[must_use]` should only be used on a type when it's desired for +functions defined outside of this crate which return the type to have +`#[must_use]` behavior. + +As a general rule of thumb, this should be restricted to types which could be +used to make security decisions. For example, digests and signatures should have +`#[must_use]`, while keys should not have it. + +*TODO(joshlf): Re-evaluate this policy? Maybe we want to put `#[must_use]` on +more types?* + +### Insecure + +Some clients require access to insecure operations in order to interoperate with +legacy applications. While we provide these operations, we do so with a few +caveats: +- We only provide the bare minimum required. For example, while we provide + HMAC-SHA1, we do not provide SHA-1 on its own, as it is not needed. +- We attempt to make it as difficult as possible for somebody to use an insecure + operation unintentionally, as detailed in the next section. + +#### Adding Insecure Operations + +We use a number of mechanisms to make it less likely for somebody to use an +insecure operation unintentionally or without understanding the implications. +They are: +- Use of Rust's `#[deprecated]` attribute so that code which uses insecure + operations will produce a compiler warning +- Naming of insecure types, functions, and methods with an "insecure" prefix so + that their use will stand out in code, and their insecurity will stand out + when reading their documentation +- Documentation comments that stress the operation's insecurity +- Placing all insecure operations in their own `insecure` module so that users + are unlikely to accidentally come across an insecure operation while browsing + other documentation +- Placing the `insecure` module behind a feature flag which is disabled by + default + +The whole is also more than the sum of the parts. Taken together, these +mechanisms serve to give an appropriate air of gravitas to insecure operations. +Users should feel uneasy - like they're wading into dangerous and subtle +territory (because they are!). They should be made to feel the gravity of the +situation, and to appreciate the importance of carefully considering whether +using an insecure operation is appropriate. + +##### Deprecation + +Rust provides the `#[deprecated]` +[attribute](https://doc.rust-lang.org/reference/attributes.html) which can be +placed on items including modules, types, functions, methods, and traits. If a +deprecated item is imported or used, it will cause a compiler warning (two, +actually - one for the import, and one for the use in code). + +In `mundane`, all insecure operations must be marked with a `#[deprecated]` +attribute with an appropriate message. This includes all items that a user could +ever interact with - types, functions, methods, etc. If it has a `pub` in front +of it, it needs a deprecation attribute. For example: + +```rust +#[deprecated(note = "Foo is considered insecure")] +pub struct InsecureFooResult; + +impl InsecureFooResult { + #[deprecated(note = "Foo is considered insecure")] + pub fn insecure_frobnicate(&self) { ... } +} + +#[deprecated(note = "Foo is considered insecure")] +pub fn insecure_foo() -> InsecureFooResult { ... } +``` + +##### Naming + +Every user-facing Rust item associated with an insecure operation carries an +"insecure" prefix on its name. For types and traits, this is of the form +`Insecure`, while for functions, methods, and modules, it's of the form +`insecure_`. See the example from the previous section for a demonstration of +this naming. + +The justification for this is twofold. First, it makes it so that, while reading +documentation, it's unlikely for even a casual reader to miss that what they're +reading about is a special case that should be carefully considered. Second, it +makes it very obvious when reading or reviewing code that makes use of insecure +operations. + +##### Documentation + +Every documentation comment on an insecure operation should have the following +structure: + +```rust +/// INSECURE: <summary of operation> +/// +/// # Security +/// +/// <operation> is considered insecure, and should only be used for compatibility +/// with legacy applications. +/// +/// <further documentation if necessary> +``` + +As with naming, this serves to lessen the likelihood that a user will use an +insecure operation without realizing what they're doing. + +##### Module Isolation + +All insecure operations are exposed through a top-level `insecure` module, which +is itself marked with a deprecation attribute, and carries appropriate +module-level documentation. + +Unfortunately, due to Rust's visibility rules, making this work involves a bit +of a dance. For reasons of practicality, insecure operations are defined +alongside their secure counterparts. For example, the `InsecureHmacSha1` type is +defined in the `hmac` module, and the `InsecureSha1Digest` type is defined in +the `hash` module. A programmer's first inclination might be to mark these as +`pub(crate)` and attempt to re-export them from the `insecure` module. +Unfortunately, Rust forbids this. + +Instead, we take the somewhat circuitous approach of putting an insecure +operation inside of its own `pub(crate)` module (e.g., +`hmac::insecure_hmac_sha1`). Inside of this module, the insecure operation can be +`pub` rather than `pub(crate)`. This, in turn, allows the `insecure` module to +re-export the item without running afoul of the compiler. It's an awkward dance, +but it makes it so that insecure operations can only be accessed through the +`insecure` module, which is a big win. + +##### Feature Gating + +By default, the `insecure` module is not present. The user must explicitly +enable the `insecure` feature in order to enable the module. + +## Contributor License Agreement + +Contributions to this project must be accompanied by a Contributor License +Agreement. You (or your employer) retain the copyright to your contribution; +this simply gives us permission to use and redistribute your contributions as +part of the project. Head over to <https://cla.developers.google.com/> to see +your current agreements on file or to sign a new one. + +You generally only need to submit a CLA once, so if you've already submitted one +(even if it was for a different project), you probably don't need to do it +again. + +## Code reviews + +All submissions, including submissions by project members, require review. We +use GitHub pull requests for this purpose. Consult +[GitHub Help](https://help.github.com/articles/about-pull-requests/) for more +information on using pull requests. + +## Community Guidelines + +This project follows [Google's Open Source Community +Guidelines](https://opensource.google.com/conduct/). \ No newline at end of file
diff --git a/Cargo.toml b/Cargo.toml new file mode 100644 index 0000000..1dd61ac --- /dev/null +++ b/Cargo.toml
@@ -0,0 +1,23 @@ +# Copyright 2018 Google LLC +# +# Use of this source code is governed by an MIT-style +# license that can be found in the LICENSE file or at +# https://opensource.org/licenses/MIT. + +[package] +name = "mundane" +# remember to update html_root_url +# TODO(joshlf): use version-sync crate to test this in CI +version = "0.2.0" +authors = ["Joshua Liebow-Feeser <joshlf@google.com>"] +description = "Cryptography which is easy to use and hard to misuse" +readme = "README.md" +license-file = "LICENSE" +keywords = ["boringssl"] +categories = ["cryptography"] +repository = "https://github.com/google/mundane" + +[features] +insecure = [] +kdf = [] +rand-bytes = []
diff --git a/DESIGN.md b/DESIGN.md new file mode 100644 index 0000000..f9ae5a5 --- /dev/null +++ b/DESIGN.md
@@ -0,0 +1,197 @@ +<!-- Copyright 2018 Google LLC + +Use of this source code is governed by an MIT-style +license that can be found in the LICENSE file or at +https://opensource.org/licenses/MIT. --> + +# Design of the `mundane` crate + +`mundane` has the following design goals, in this order: +- To be difficult to misuse +- To be ergonomic +- To be performant + +This document describes both the overall philosophy, and also specific design +patterns used to achieve these goals + +# Philosophy + +Cryptography is famously subtle and easy to get wrong. And when cryptography is +done wrong, the results can be catastrophic. + +Experience has shown that most programmers, not being familiar with the +subtleties of cryptography, will unknowingly misuse cryptographic libraries if +they are allowed. This is one example of a broader trend - that it's difficult +to get something right if getting it wrong doesn't affect whether your program +runs. It's the same reason that error handling code is so often buggy in +otherwise well-written programs. Misuse of cryptography, like buggy error +handling, is unlikely to show up in tests, and unlikely to affect the +correctness of a program under normal conditions. But unlike error handling, +most programmers aren't familiar with the requirements of using cryptography +securely, and getting it wrong can be absolutely fatal. + +Given this realization, `mundane` takes the approach of giving the programmer +the fewest degrees of freedom possible. Doing the right thing should be easy and +feel natural. Doing the wrong thing should feel difficult and ideally be +entirely impossible. This philosophy motivates the design patterns which are +explored in the next section. + +# Design Patterns + +## Do work for the user + +Some cryptographic operations have setup phases, require generating random +values, computing key schedules, etc. While many cryptographic APIs split these +into multiple steps that must be performed by the user in the right order, +prefer APIs which perform all setup steps on behalf of the user. This reduces +the opportunities for the user to make a mistake. + +For example, the scrypt password-based key derivation function takes a salt. +When generating a key from a new password, the salt should always be randomly +generated anew. Instead of taking the salt as an argument, as many cryptographic +APIs do, we generate the salt as part of the generation function - +`scrypt_generate` - so that the user is not given the opportunity to improperly +generate it. + +As another example, while scrypt can be used as a general-purpose key derivation +function, we expose it specifically for password verification. Thus, instead of +having the API expose the ability to take a password and a salt and generate a +hash, leaving it up to the user to verify that the calculated hash matches the +expected one, our API takes a password, a salt, and a hash, computes the new +hash, checks it against the expected one, and returns a boolean. Not only does +this ensure that the comparison is not accidentally skipped, it also allows us +to ensure that the comparison is performed using a constant-time comparison +function, which is a subtle detail that is often overlooked by users. + +## Types + +All cryptographic operations have data associated with them. A hash function +takes a byte sequence and outputs a digest. A signature functions takes a +private key and a digest, and outputs a signature. + +These types of data usually have strict definitions of what operations are valid +or secure to perform on them. The Rust type system provides a powerful mechanism +to enforce that users cannot use these cryptographic objects other than as +intended. + +### Opaque types + +The easiest way to restrict the set of allowed operations on a type is to make +it opaque - that is, to create a struct with private fields, and provide only +the minimum set of methods or trait implementations needed. For example, instead +of representing a SHA-256 digest as a `[u8; 32]`, we represent it as an opaque +struct, `Sha256Digest`, which has a private `[u8; 32]` field. + +Given such an opaque type, we can be judicious about methods or trait +implementations to provide. For example, a SHA-256 digest should be comparable +for equality with other SHA-256 digests, and so `Sha256Digest` implements `Eq` +for itself. However, comparing with digests from other hash functions is not a +cryptographically meaningful operation, so it doesn't implement `Eq` for other +types of digests. Similarly, the `EcdsaSignature` type provides only a +constructor and a getter, as no other operations (including comparison between +signatures) are meaningful. + +It will usually be necessary to allow the user to access a non-opaque +representation (such as a byte array for hash digests). However, it is +sufficient to only provide constructors and getters. For example, the `Digest` +trait provides a `from_bytes(bytes: [u8; Self::DIGEST_LEN]) -> Self` +constructor, and a `bytes(&self) -> [u8; Self::DIGEST_LEN]` getter, but does not +provide, for example, `bytes_mut(&mut self) -> &mut [u8; Self::DIGEST_LEN]`. + +### Use distinct types even if they have the same operations + +Sometimes, distinct cryptographic objects will have the same representations and +operations allowed on them. For example, both RIPEMD-160 and SHA-1 produce +20-byte digests. Even if this happens, distinct Rust types should still be used. +Since it is never valid to compare a RIPEMD-160 digest to a SHA-1 digest, +representing them with the same Rust type would allow operations that are not +valid. Representing them with distinct Rust types ensures that they are not +spuriously used together in an invalid or insecure way. + +### Use the most restrictive type + +At some point, it will be necessary to accept or provide a non-opaque +representation so that input can be gathered from the outside world or output to +it. When this happens, use the most restrictive type in order to avoid having +to perform validation at runtime. + +For example, hash digests have a fixed length. Thus, their constructors accept +(and their getters produce) fixed-length byte arrays. If, instead, +variable-length byte slices were used, it would be necessary a) to document the +length requirement, b) to validate the length during construction, and panic if +it failed, and c) to promise to the user to always produce slices of a +particular length. By using fixed-length arrays, we allow the type system to +guarantee that input will always be valid - so we don't need to perform any +validation - and to guarantee that the output will always conform to what is +documented - so the user doesn't need to simply trust our documentation. + +### Put as much as possible in the type system + +If a distinction exists between two cryptographic objects, always try to encode +that distinction in the type system if possible (of course, don't go over board; +ergonomics and other considerations are important too). + +For example, most cryptography libraries provide a single elliptic curve private +key type. However, elliptic curve keys have a curve parameter, and two keys over +different curves are not interchangable - they might as well be completely +different cryptosystems. Thus, we provide a `PCurve` trait which is implemented +by various curve types, and our private key type, `EcKey` is parametrized on +such a type - `EcKey<C: PCurve>`. + +## Errors + +Error return values from cryptographic functions are an infamous source of +vulnerabilities. As with any system, the error handling logic of a program is +often the last consideration of a programmer, and is rarely exercised in tests. +More so than most systems, however, failure to properly handle errors from +cryptographic functions can easily lead to catastrophic vulnerabilities. + +In order to avoid an opportunity for error values to be misused, we follow +the following design guidelines: +- Always use the Rust `Result` type to report errors. This may be a no-brainer, + but it means that, if the user wants to extract the return value from a + function, they *must* handle errors (at the very least, by calling `unwrap` or + `expect`, and thus panicking on failure). This contrasts with a language like + C, in which failing to check status return codes is easy and a common source + of bugs. +- Collapse the distinction between "verification failed" and "verification + encountered an error." When verifying cryptographic objects like comparing + digests, verifying signatures, etc, there can sometimes be errors that are not + the same as a verification failure. For example, a verification routine might + fail to allocate memory, or it might fail to parse an encoded signature. + Instead of having a verification routine provide three possible return values + (verification succeeded, verification failed, or error encountered) we + collapse the last two into a single one - verification failed. That way, the + user is never given the opportunity to try to make subtle error-handling + decisions that might lead to them mistakenly accepting an invalid signature as + valid. +- If an error requires particularly subtle error-handling, prefer panicking or + aborting the process. When cryptographic operations fail in a way that would + require reporting an error to the user (in other words, there's no valid + non-error interpretation like in the case of signature verification), and + handling that failure is particularly error-prone, it may be justified to make + the function's API infallible, and instead panic or abort the process on + error. BoringSSL famously does this when failing to read randomness (e.g., + from `/dev/urandom`), as this has historically been a source of + vulnerabilities. + +## Attributes + +Rust has two attributes which will cause compiler warnings in user code +if elements of the `mundane` API are misused. +- The `#[must_use]` attribute on a function causes a compiler warning if a user + calls the function and discards the result. We put this attribute on all + functions which return values, as it is always suspicious to call a + side-effect-free function and ignore its result (most of our functions which + return values are side-effect free). This is especially useful in cases like + signature or hash verification, where failure to check the return value from a + function could lead to a catastrophic vulnerability (the iOS [`goto fail` TLS + verification + bug](https://nakedsecurity.sophos.com/2014/02/24/anatomy-of-a-goto-fail-apples-ssl-bug-explained-plus-an-unofficial-patch/) + is a famous example of this). + + Similarly, `#[must_use]` on a type will cause a compiler warning if a user + ever calls a function which returns that type and discards the result. +- The `#[deprecated]` attribute causes a warning whenever an item is imported or + used anywhere in code. We make liberal use of this attribute for our insecure, + legacy-only operations like SHA-1. See `CONTRIBUTING.md` for more details. \ No newline at end of file
diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..e5ccb02 --- /dev/null +++ b/LICENSE
@@ -0,0 +1,18 @@ +Copyright 2018 Google LLC. All rights reserved. + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +the Software, and to permit persons to whom the Software is furnished to do so, +subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/README.md b/README.md new file mode 100644 index 0000000..652edb3 --- /dev/null +++ b/README.md
@@ -0,0 +1,48 @@ +<!-- Copyright 2018 Google LLC + +Use of this source code is governed by an MIT-style +license that can be found in the LICENSE file or at +https://opensource.org/licenses/MIT. --> + +# mundane + +`mundane` is a Rust cryptography library backed by BoringSSL that is difficult +to misuse, ergonomic, and performant (in that order). + +## Dependencies + +`mundane` vendors a copy of the BoringSSL source, so BoringSSL does not need to +be installed locally in order to build. However, the BoringSSL build system has +the following dependencies: +- [CMake](https://cmake.org/download/) 2.8.11 or later +- Perl 5.6.1 or later. See [BoringSSL's build + instructions](https://boringssl.googlesource.com/boringssl/+/master/BUILDING.md) + for what to do if CMake fails to find Perl on your system. +- Either Make or [Ninja](https://ninja-build.org/). Ninja is preferable, as it + makes compilation significantly faster; if both are present, Ninja will be + used. On Windows, Ninja is required. +- A C compiler +- Go +- To build the x86 and x86_64 assembly, your assembler must support AVX2 + instructions and `MOVBE`. If using GNU binutils, you must have 2.22 or later. + +In order to avoid errors at link time due to conflicting symbols, we build +BoringSSL with a custom prefix for all of its symbols which is based on the name +and version of this crate. That way, even if multiple different versions of +`mundane` are present in the same dependency graph, none of the symbols from one +version's BoringSSL will conflict with the symbols from another version's +BoringSSL. + +## Supported platforms + +`mundane` supports being built on and for Linux and Mac. Windows support is +under development. Cross-compilation is not supported. + +## License + +Everything outside of the `boringssl/boringssl` directory is licensed under an +MIT license which can be found in the `LICENSE` file. Everything in the +`boringssl/boringssl` directory is licensed with a license that can be found in +the `boringssl/boringssl/LICENSE` file. + +Disclaimer: mundane is not an officially supported Google product.
diff --git a/boringssl/README.md b/boringssl/README.md new file mode 100644 index 0000000..d462c91 --- /dev/null +++ b/boringssl/README.md
@@ -0,0 +1,96 @@ +<!-- Copyright 2018 Google LLC + +Use of this source code is governed by an MIT-style +license that can be found in the LICENSE file or at +https://opensource.org/licenses/MIT. --> + +# boringssl + +This directory contains source code and Rust bindings for Google's +[BoringSSL](https://boringssl.googlesource.com/boringssl/) library. + +## Versions + +BoringSSL is vendored here, so each version of `mundane` will depend on a +particular version of BoringSSL. Each new release will usually vendor the latest +version of BoringSSL in order to pick up bug fixes and improvements. + +## Bindings + +Rust bindings live in `boringssl.rs`. This file is included from the main +`mundane` source code using a `#[path]` attribute. + +These bindings are auto-generated using the `bindgen.sh` script, although some +manual intervention is required. In particular, after running `bindgen.sh`, each +public function must be annotated with a `#[link_name]` attribute (the reason +for these attributes is explained in the following section). For example, given +the following bindgen output: + +```rust +extern "C" { + pub fn CBS_init(cbs: *mut CBS, data: *const u8, len: usize); +} +``` + +We add a `#[link_name]` attribute as follows, where X.Y.Z is the current crate +version. + +```rust +extern "C" { + #[link_name = "__RUST_MUNDANE_X_Y_Z_CBS_init"] + pub fn CBS_init(cbs: *mut CBS, data: *const u8, len: usize); +} +``` + +## Symbol Prefixing + +Normally, the C build system does not allow multiple copies of the same codebase +to be linked together since the namespace for C symbols is global at link time. +In order to avoid this problem, we compile BoringSSL with a custom symbol prefix +specific to the crate version. This document describes the details of how this +works. + +### Prefixing + +Each BoringSSL symbol is given a prefix of `__RUST_MUNDANE_X_Y_Z_`, where the +current crate version number is X.Y.Z. This way, if two different versions of +the crate are present during a build, no C symbol will be defined under the same +name in both builds of BoringSSL. + +### Two-phase build + +BoringSSL's build system has built-in support for symbol prefixing. However, it +requires that the caller provide a list of symbols which need to be prefixed. +Since the set of symbols present is highly platform-dependent, a static list +would be very brittle and error-prone. Instead, we discover the symbols +dynamically at build time by doing a two-phase build. + +In the first phase, we build BoringSSL as normal, with no symbol prefixing. +Then, using a Go program provided by BoringSSL, we scrape the list of symbols +from the build artifacts. Using this list, we run the build again - the second +phase - this time using BoringSSL's symbol prefixing feature. We use the +artifacts from the second build when performing the final Rust build. + +### Library names + +We instruct Rust to use the appropriate build artifacts using the linker path. +The linker path is used in a manner similar to the binary `$PATH` in Unix +systems. When a library is requested, the linker searches for a build artifact +of the appropriate name, stopping its search once it has found the appropriate +library. For example, given the argument `-l foo`, the linker would search for a +file called `libfoo.a`. + +In order to ensure that the linker is able to find all copies of the BoringSSL +build artifacts, we give them unique names. If we didn't, only the first +artifact found in the filesystem would be used. Currently, we only link against +the `crypto` library, which, in the normal build system, is stored in +`libcrypto.a`. In order to make sure that all versions of this library are found +by the linker - one per version of the crate - we rename them just as we rename +symbols. For crate version x.y.z, we rename `libcrypto.a` to +`libcrypto_x_y_z.a`, and instruct the linker to look for the `crypto_x_y_z` +library. + +### Testing + +In order to test that symbol prefixing is working properly, use the +`test_symbol_conflicts.sh` script in this directory. \ No newline at end of file
diff --git a/boringssl/bindgen.h b/boringssl/bindgen.h new file mode 100644 index 0000000..8297e68 --- /dev/null +++ b/boringssl/bindgen.h
@@ -0,0 +1,17 @@ +// Copyright 2018 Google LLC +// +// Use of this source code is governed by an MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT. + +#include <openssl/bytestring.h> +#include <openssl/curve25519.h> +#include <openssl/ec.h> +#include <openssl/ec_key.h> +#include <openssl/ecdsa.h> +#include <openssl/err.h> +#include <openssl/evp.h> +#include <openssl/hmac.h> +#include <openssl/mem.h> +#include <openssl/rand.h> +#include <openssl/sha.h>
diff --git a/boringssl/bindgen.sh b/boringssl/bindgen.sh new file mode 100755 index 0000000..c7ef530 --- /dev/null +++ b/boringssl/bindgen.sh
@@ -0,0 +1,145 @@ +#!/bin/bash + +# Copyright 2018 Google LLC +# +# Use of this source code is governed by an MIT-style +# license that can be found in the LICENSE file or at +# https://opensource.org/licenses/MIT. + +set -e + +# cd to the directory this script lives in +readonly SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +cd "$SCRIPT_DIR" + +if [ $# -ne 3 ]; then + echo "Usage: $0 <major> <minor> <patch>" >&2 + exit 1 +fi + +MAJOR="$1" +MINOR="$2" +PATCH="$3" + +# TODO(joshlf): +# - Use the --use-core flag once std isn't required (see +# https://github.com/rust-lang-nursery/rust-bindgen/issues/1015) + +# Only include the symbols we want. It's important that we take the minimum +# dependency on BoringSSL so that we provide the minimum burden for them. The +# more symbols we depend on, the more likely it is that a change that they want +# to make will affect us, which they will care about, making them either expend +# effort in a graceful transition or decide to abandon the change. Thus, instead +# of whitelisting broad classes of symbols, we explicitly whitelist the exact +# list of symbols that mundane depends on. +WHITELIST="(CBB|\ +CBB_cleanup|\ +CBB_data|\ +CBB_init|\ +CBB_len|\ +CBS|\ +CBS_init|\ +CBS_len|\ +CRYPTO_memcmp|\ +ECDSA_sign|\ +ECDSA_size|\ +ECDSA_verify|\ +EC_GROUP|\ +EC_GROUP_get_curve_name|\ +EC_GROUP_new_by_curve_name|\ +EC_KEY|\ +EC_KEY_free|\ +EC_KEY_generate_key|\ +EC_KEY_get0_group|\ +EC_KEY_marshal_private_key|\ +EC_KEY_new|\ +EC_KEY_parse_private_key|\ +EC_KEY_set_group|\ +EC_KEY_up_ref|\ +EC_curve_nid2nist|\ +ED25519_PRIVATE_KEY_LEN|\ +ED25519_PUBLIC_KEY_LEN|\ +ED25519_SIGNATURE_LEN|\ +ED25519_keypair|\ +ED25519_keypair_from_seed|\ +ED25519_sign|\ +ED25519_verify|\ +ERR_print_errors_cb|\ +EVP_MD|\ +EVP_PBE_scrypt|\ +EVP_PKEY|\ +EVP_PKEY_assign_EC_KEY|\ +EVP_PKEY_free|\ +EVP_PKEY_get1_EC_KEY|\ +EVP_PKEY_new|\ +EVP_PKEY_up_ref|\ +EVP_marshal_public_key|\ +EVP_parse_public_key|\ +EVP_sha1|\ +EVP_sha256|\ +EVP_sha384|\ +EVP_sha512|\ +HMAC_CTX|\ +HMAC_CTX_cleanup|\ +HMAC_CTX_init|\ +HMAC_Final|\ +HMAC_Init_ex|\ +HMAC_Update|\ +HMAC_size|\ +NID_X9_62_prime256v1|\ +NID_secp384r1|\ +NID_secp521r1|\ +RAND_bytes|\ +PKCS5_PBKDF2_HMAC|\ +SHA_CTX|\ +SHA_DIGEST_LENGTH|\ +SHA1_Final|\ +SHA1_Init|\ +SHA1_Update|\ +SHA256_CTX|\ +SHA256_DIGEST_LENGTH|\ +SHA256_Final|\ +SHA256_Init|\ +SHA256_Update|\ +SHA512_CTX|\ +SHA384_DIGEST_LENGTH|\ +SHA384_Final|\ +SHA384_Init|\ +SHA384_Update|\ +SHA512_CTX|\ +SHA512_DIGEST_LENGTH|\ +SHA512_Final|\ +SHA512_Init|\ +SHA512_Update)" + +# NOTE(joshlf): Currently, we don't pass --target since none of the symbols +# we're linking against are architecture-specific (TODO: are any of them +# word-size-specific?). If this ever becomes a problem, then the thing to do is +# probably to generate different files for different platforms +# (boringssl_x86_64.rs, boringssl_arm64.rs, etc) and conditionally compile them +# depending on target. +bindgen bindgen.h --whitelist-function "$WHITELIST" --whitelist-type "$WHITELIST" \ + --whitelist-var "$WHITELIST" -o boringssl.rs -- -I ./boringssl/include + +TMP="$(mktemp)" + +# Prepend copyright comment, #[allow] for various warnings we don't care about, +# and a line telling Rust to link against libcrypto. +cat >> "$TMP" <<'EOF' +// Copyright 2018 Google LLC +// +// Use of this source code is governed by an MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT. + +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] + +#[link(name = "crypto_${MAJOR}_${MINOR}_${PATCH}")] extern {} + +EOF +cat boringssl.rs >> "$TMP" + +mv "$TMP" boringssl.rs +rustfmt boringssl.rs
diff --git a/boringssl/boringssl b/boringssl/boringssl new file mode 160000 index 0000000..892a31b --- /dev/null +++ b/boringssl/boringssl
@@ -0,0 +1 @@ +Subproject commit 892a31b5fb6f621903681f4f597156e3db3526fe
diff --git a/boringssl/boringssl.rs b/boringssl/boringssl.rs new file mode 100644 index 0000000..714ef5f --- /dev/null +++ b/boringssl/boringssl.rs
@@ -0,0 +1,1219 @@ +// Copyright 2018 Google LLC +// +// Use of this source code is governed by an MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT. + +// Some symbols are only used with certain features enabled, so we need to +// suppress the unused warning when those features aren't enabled. +#![allow(unused)] +// Only necessary for test_symbol_conflict.sh, which exposes these symbols +// through mundane's public interface. +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] + +#[link(name = "crypto_0_2_0")] +extern "C" {} + +/* automatically generated by rust-bindgen */ + +pub const ED25519_PRIVATE_KEY_LEN: u32 = 64; +pub const ED25519_PUBLIC_KEY_LEN: u32 = 32; +pub const ED25519_SIGNATURE_LEN: u32 = 64; +pub const NID_X9_62_prime256v1: u32 = 415; +pub const NID_secp384r1: u32 = 715; +pub const NID_secp521r1: u32 = 716; +pub const SHA_DIGEST_LENGTH: u32 = 20; +pub const SHA256_DIGEST_LENGTH: u32 = 32; +pub const SHA384_DIGEST_LENGTH: u32 = 48; +pub const SHA512_DIGEST_LENGTH: u32 = 64; +pub type CBB = cbb_st; +pub type CBS = cbs_st; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct dh_st { + _unused: [u8; 0], +} +pub type DH = dh_st; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct dsa_st { + _unused: [u8; 0], +} +pub type DSA = dsa_st; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct ec_group_st { + _unused: [u8; 0], +} +pub type EC_GROUP = ec_group_st; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct ec_key_st { + _unused: [u8; 0], +} +pub type EC_KEY = ec_key_st; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct engine_st { + _unused: [u8; 0], +} +pub type ENGINE = engine_st; +pub type EVP_MD_CTX = env_md_ctx_st; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct env_md_st { + _unused: [u8; 0], +} +pub type EVP_MD = env_md_st; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct evp_pkey_asn1_method_st { + _unused: [u8; 0], +} +pub type EVP_PKEY_ASN1_METHOD = evp_pkey_asn1_method_st; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct evp_pkey_ctx_st { + _unused: [u8; 0], +} +pub type EVP_PKEY_CTX = evp_pkey_ctx_st; +pub type EVP_PKEY = evp_pkey_st; +pub type HMAC_CTX = hmac_ctx_st; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct rsa_st { + _unused: [u8; 0], +} +pub type RSA = rsa_st; +pub type SHA256_CTX = sha256_state_st; +pub type SHA512_CTX = sha512_state_st; +pub type SHA_CTX = sha_state_st; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct cbs_st { + pub data: *const u8, + pub len: usize, +} +#[test] +fn bindgen_test_layout_cbs_st() { + assert_eq!( + ::std::mem::size_of::<cbs_st>(), + 16usize, + concat!("Size of: ", stringify!(cbs_st)) + ); + assert_eq!( + ::std::mem::align_of::<cbs_st>(), + 8usize, + concat!("Alignment of ", stringify!(cbs_st)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<cbs_st>())).data as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(cbs_st), + "::", + stringify!(data) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<cbs_st>())).len as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(cbs_st), + "::", + stringify!(len) + ) + ); +} +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_CBS_init"] + pub fn CBS_init(cbs: *mut CBS, data: *const u8, len: usize); +} +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_CBS_len"] + pub fn CBS_len(cbs: *const CBS) -> usize; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct cbb_buffer_st { + pub buf: *mut u8, + pub len: usize, + pub cap: usize, + pub can_resize: ::std::os::raw::c_char, + pub error: ::std::os::raw::c_char, +} +#[test] +fn bindgen_test_layout_cbb_buffer_st() { + assert_eq!( + ::std::mem::size_of::<cbb_buffer_st>(), + 32usize, + concat!("Size of: ", stringify!(cbb_buffer_st)) + ); + assert_eq!( + ::std::mem::align_of::<cbb_buffer_st>(), + 8usize, + concat!("Alignment of ", stringify!(cbb_buffer_st)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<cbb_buffer_st>())).buf as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(cbb_buffer_st), + "::", + stringify!(buf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<cbb_buffer_st>())).len as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(cbb_buffer_st), + "::", + stringify!(len) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<cbb_buffer_st>())).cap as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(cbb_buffer_st), + "::", + stringify!(cap) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<cbb_buffer_st>())).can_resize as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(cbb_buffer_st), + "::", + stringify!(can_resize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<cbb_buffer_st>())).error as *const _ as usize }, + 25usize, + concat!( + "Offset of field: ", + stringify!(cbb_buffer_st), + "::", + stringify!(error) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct cbb_st { + pub base: *mut cbb_buffer_st, + pub child: *mut CBB, + pub offset: usize, + pub pending_len_len: u8, + pub pending_is_asn1: ::std::os::raw::c_char, + pub is_top_level: ::std::os::raw::c_char, +} +#[test] +fn bindgen_test_layout_cbb_st() { + assert_eq!( + ::std::mem::size_of::<cbb_st>(), + 32usize, + concat!("Size of: ", stringify!(cbb_st)) + ); + assert_eq!( + ::std::mem::align_of::<cbb_st>(), + 8usize, + concat!("Alignment of ", stringify!(cbb_st)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<cbb_st>())).base as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(cbb_st), + "::", + stringify!(base) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<cbb_st>())).child as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(cbb_st), + "::", + stringify!(child) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<cbb_st>())).offset as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(cbb_st), + "::", + stringify!(offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<cbb_st>())).pending_len_len as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(cbb_st), + "::", + stringify!(pending_len_len) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<cbb_st>())).pending_is_asn1 as *const _ as usize }, + 25usize, + concat!( + "Offset of field: ", + stringify!(cbb_st), + "::", + stringify!(pending_is_asn1) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<cbb_st>())).is_top_level as *const _ as usize }, + 26usize, + concat!( + "Offset of field: ", + stringify!(cbb_st), + "::", + stringify!(is_top_level) + ) + ); +} +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_CBB_init"] + pub fn CBB_init(cbb: *mut CBB, initial_capacity: usize) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_CBB_cleanup"] + pub fn CBB_cleanup(cbb: *mut CBB); +} +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_CBB_data"] + pub fn CBB_data(cbb: *const CBB) -> *const u8; +} +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_CBB_len"] + pub fn CBB_len(cbb: *const CBB) -> usize; +} +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_ED25519_keypair"] + pub fn ED25519_keypair(out_public_key: *mut u8, out_private_key: *mut u8); +} +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_ED25519_sign"] + pub fn ED25519_sign( + out_sig: *mut u8, message: *const u8, message_len: usize, private_key: *const u8, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_ED25519_verify"] + pub fn ED25519_verify( + message: *const u8, message_len: usize, signature: *const u8, public_key: *const u8, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_ED25519_keypair_from_seed"] + pub fn ED25519_keypair_from_seed( + out_public_key: *mut u8, out_private_key: *mut u8, seed: *const u8, + ); +} +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_EC_GROUP_new_by_curve_name"] + pub fn EC_GROUP_new_by_curve_name(nid: ::std::os::raw::c_int) -> *mut EC_GROUP; +} +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_EC_GROUP_get_curve_name"] + pub fn EC_GROUP_get_curve_name(group: *const EC_GROUP) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_EC_curve_nid2nist"] + pub fn EC_curve_nid2nist(nid: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char; +} +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_EC_KEY_new"] + pub fn EC_KEY_new() -> *mut EC_KEY; +} +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_EC_KEY_free"] + pub fn EC_KEY_free(key: *mut EC_KEY); +} +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_EC_KEY_up_ref"] + pub fn EC_KEY_up_ref(key: *mut EC_KEY) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_EC_KEY_get0_group"] + pub fn EC_KEY_get0_group(key: *const EC_KEY) -> *const EC_GROUP; +} +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_EC_KEY_set_group"] + pub fn EC_KEY_set_group(key: *mut EC_KEY, group: *const EC_GROUP) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_EC_KEY_generate_key"] + pub fn EC_KEY_generate_key(key: *mut EC_KEY) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_EC_KEY_parse_private_key"] + pub fn EC_KEY_parse_private_key(cbs: *mut CBS, group: *const EC_GROUP) -> *mut EC_KEY; +} +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_EC_KEY_marshal_private_key"] + pub fn EC_KEY_marshal_private_key( + cbb: *mut CBB, key: *const EC_KEY, enc_flags: ::std::os::raw::c_uint, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_ECDSA_sign"] + pub fn ECDSA_sign( + type_: ::std::os::raw::c_int, digest: *const u8, digest_len: usize, sig: *mut u8, + sig_len: *mut ::std::os::raw::c_uint, key: *const EC_KEY, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_ECDSA_verify"] + pub fn ECDSA_verify( + type_: ::std::os::raw::c_int, digest: *const u8, digest_len: usize, sig: *const u8, + sig_len: usize, key: *const EC_KEY, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_ECDSA_size"] + pub fn ECDSA_size(key: *const EC_KEY) -> usize; +} +pub type ERR_print_errors_callback_t = ::std::option::Option< + unsafe extern "C" fn( + str: *const ::std::os::raw::c_char, + len: usize, + ctx: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, +>; +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_ERR_print_errors_cb"] + pub fn ERR_print_errors_cb( + callback: ERR_print_errors_callback_t, ctx: *mut ::std::os::raw::c_void, + ); +} +pub type CRYPTO_refcount_t = u32; +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_EVP_sha1"] + pub fn EVP_sha1() -> *const EVP_MD; +} +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_EVP_sha256"] + pub fn EVP_sha256() -> *const EVP_MD; +} +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_EVP_sha384"] + pub fn EVP_sha384() -> *const EVP_MD; +} +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_EVP_sha512"] + pub fn EVP_sha512() -> *const EVP_MD; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct evp_md_pctx_ops { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct env_md_ctx_st { + pub digest: *const EVP_MD, + pub md_data: *mut ::std::os::raw::c_void, + pub pctx: *mut EVP_PKEY_CTX, + pub pctx_ops: *const evp_md_pctx_ops, +} +#[test] +fn bindgen_test_layout_env_md_ctx_st() { + assert_eq!( + ::std::mem::size_of::<env_md_ctx_st>(), + 32usize, + concat!("Size of: ", stringify!(env_md_ctx_st)) + ); + assert_eq!( + ::std::mem::align_of::<env_md_ctx_st>(), + 8usize, + concat!("Alignment of ", stringify!(env_md_ctx_st)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<env_md_ctx_st>())).digest as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(env_md_ctx_st), + "::", + stringify!(digest) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<env_md_ctx_st>())).md_data as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(env_md_ctx_st), + "::", + stringify!(md_data) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<env_md_ctx_st>())).pctx as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(env_md_ctx_st), + "::", + stringify!(pctx) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<env_md_ctx_st>())).pctx_ops as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(env_md_ctx_st), + "::", + stringify!(pctx_ops) + ) + ); +} +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_EVP_PKEY_new"] + pub fn EVP_PKEY_new() -> *mut EVP_PKEY; +} +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_EVP_PKEY_free"] + pub fn EVP_PKEY_free(pkey: *mut EVP_PKEY); +} +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_EVP_PKEY_up_ref"] + pub fn EVP_PKEY_up_ref(pkey: *mut EVP_PKEY) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_EVP_PKEY_assign_EC_KEY"] + pub fn EVP_PKEY_assign_EC_KEY(pkey: *mut EVP_PKEY, key: *mut EC_KEY) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_EVP_PKEY_get1_EC_KEY"] + pub fn EVP_PKEY_get1_EC_KEY(pkey: *const EVP_PKEY) -> *mut EC_KEY; +} +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_EVP_parse_public_key"] + pub fn EVP_parse_public_key(cbs: *mut CBS) -> *mut EVP_PKEY; +} +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_EVP_marshal_public_key"] + pub fn EVP_marshal_public_key(cbb: *mut CBB, key: *const EVP_PKEY) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_PKCS5_PBKDF2_HMAC"] + pub fn PKCS5_PBKDF2_HMAC( + password: *const ::std::os::raw::c_char, password_len: usize, salt: *const u8, + salt_len: usize, iterations: ::std::os::raw::c_uint, digest: *const EVP_MD, key_len: usize, + out_key: *mut u8, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_EVP_PBE_scrypt"] + pub fn EVP_PBE_scrypt( + password: *const ::std::os::raw::c_char, password_len: usize, salt: *const u8, + salt_len: usize, N: u64, r: u64, p: u64, max_mem: usize, out_key: *mut u8, key_len: usize, + ) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct evp_pkey_st { + pub references: CRYPTO_refcount_t, + pub type_: ::std::os::raw::c_int, + pub pkey: evp_pkey_st__bindgen_ty_1, + pub ameth: *const EVP_PKEY_ASN1_METHOD, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union evp_pkey_st__bindgen_ty_1 { + pub ptr: *mut ::std::os::raw::c_void, + pub rsa: *mut RSA, + pub dsa: *mut DSA, + pub dh: *mut DH, + pub ec: *mut EC_KEY, + _bindgen_union_align: u64, +} +#[test] +fn bindgen_test_layout_evp_pkey_st__bindgen_ty_1() { + assert_eq!( + ::std::mem::size_of::<evp_pkey_st__bindgen_ty_1>(), + 8usize, + concat!("Size of: ", stringify!(evp_pkey_st__bindgen_ty_1)) + ); + assert_eq!( + ::std::mem::align_of::<evp_pkey_st__bindgen_ty_1>(), + 8usize, + concat!("Alignment of ", stringify!(evp_pkey_st__bindgen_ty_1)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<evp_pkey_st__bindgen_ty_1>())).ptr as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(evp_pkey_st__bindgen_ty_1), + "::", + stringify!(ptr) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<evp_pkey_st__bindgen_ty_1>())).rsa as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(evp_pkey_st__bindgen_ty_1), + "::", + stringify!(rsa) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<evp_pkey_st__bindgen_ty_1>())).dsa as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(evp_pkey_st__bindgen_ty_1), + "::", + stringify!(dsa) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<evp_pkey_st__bindgen_ty_1>())).dh as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(evp_pkey_st__bindgen_ty_1), + "::", + stringify!(dh) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<evp_pkey_st__bindgen_ty_1>())).ec as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(evp_pkey_st__bindgen_ty_1), + "::", + stringify!(ec) + ) + ); +} +#[test] +fn bindgen_test_layout_evp_pkey_st() { + assert_eq!( + ::std::mem::size_of::<evp_pkey_st>(), + 24usize, + concat!("Size of: ", stringify!(evp_pkey_st)) + ); + assert_eq!( + ::std::mem::align_of::<evp_pkey_st>(), + 8usize, + concat!("Alignment of ", stringify!(evp_pkey_st)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<evp_pkey_st>())).references as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(evp_pkey_st), + "::", + stringify!(references) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<evp_pkey_st>())).type_ as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(evp_pkey_st), + "::", + stringify!(type_) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<evp_pkey_st>())).pkey as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(evp_pkey_st), + "::", + stringify!(pkey) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<evp_pkey_st>())).ameth as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(evp_pkey_st), + "::", + stringify!(ameth) + ) + ); +} +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_HMAC_CTX_init"] + pub fn HMAC_CTX_init(ctx: *mut HMAC_CTX); +} +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_HMAC_CTX_cleanup"] + pub fn HMAC_CTX_cleanup(ctx: *mut HMAC_CTX); +} +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_HMAC_Init_ex"] + pub fn HMAC_Init_ex( + ctx: *mut HMAC_CTX, key: *const ::std::os::raw::c_void, key_len: usize, md: *const EVP_MD, + impl_: *mut ENGINE, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_HMAC_Update"] + pub fn HMAC_Update( + ctx: *mut HMAC_CTX, data: *const u8, data_len: usize, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_HMAC_Final"] + pub fn HMAC_Final( + ctx: *mut HMAC_CTX, out: *mut u8, out_len: *mut ::std::os::raw::c_uint, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_HMAC_size"] + pub fn HMAC_size(ctx: *const HMAC_CTX) -> usize; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct hmac_ctx_st { + pub md: *const EVP_MD, + pub md_ctx: EVP_MD_CTX, + pub i_ctx: EVP_MD_CTX, + pub o_ctx: EVP_MD_CTX, +} +#[test] +fn bindgen_test_layout_hmac_ctx_st() { + assert_eq!( + ::std::mem::size_of::<hmac_ctx_st>(), + 104usize, + concat!("Size of: ", stringify!(hmac_ctx_st)) + ); + assert_eq!( + ::std::mem::align_of::<hmac_ctx_st>(), + 8usize, + concat!("Alignment of ", stringify!(hmac_ctx_st)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<hmac_ctx_st>())).md as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(hmac_ctx_st), + "::", + stringify!(md) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<hmac_ctx_st>())).md_ctx as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(hmac_ctx_st), + "::", + stringify!(md_ctx) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<hmac_ctx_st>())).i_ctx as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(hmac_ctx_st), + "::", + stringify!(i_ctx) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<hmac_ctx_st>())).o_ctx as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(hmac_ctx_st), + "::", + stringify!(o_ctx) + ) + ); +} +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_CRYPTO_memcmp"] + pub fn CRYPTO_memcmp( + a: *const ::std::os::raw::c_void, b: *const ::std::os::raw::c_void, len: usize, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_RAND_bytes"] + pub fn RAND_bytes(buf: *mut u8, len: usize) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_SHA1_Init"] + pub fn SHA1_Init(sha: *mut SHA_CTX) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_SHA1_Update"] + pub fn SHA1_Update( + sha: *mut SHA_CTX, data: *const ::std::os::raw::c_void, len: usize, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_SHA1_Final"] + pub fn SHA1_Final(md: *mut u8, sha: *mut SHA_CTX) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct sha_state_st { + pub __bindgen_anon_1: sha_state_st__bindgen_ty_1, + pub Nl: u32, + pub Nh: u32, + pub data: [u8; 64usize], + pub num: ::std::os::raw::c_uint, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union sha_state_st__bindgen_ty_1 { + pub h: [u32; 5usize], + pub __bindgen_anon_1: sha_state_st__bindgen_ty_1__bindgen_ty_1, + _bindgen_union_align: [u32; 5usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sha_state_st__bindgen_ty_1__bindgen_ty_1 { + pub h0: u32, + pub h1: u32, + pub h2: u32, + pub h3: u32, + pub h4: u32, +} +#[test] +fn bindgen_test_layout_sha_state_st__bindgen_ty_1__bindgen_ty_1() { + assert_eq!( + ::std::mem::size_of::<sha_state_st__bindgen_ty_1__bindgen_ty_1>(), + 20usize, + concat!( + "Size of: ", + stringify!(sha_state_st__bindgen_ty_1__bindgen_ty_1) + ) + ); + assert_eq!( + ::std::mem::align_of::<sha_state_st__bindgen_ty_1__bindgen_ty_1>(), + 4usize, + concat!( + "Alignment of ", + stringify!(sha_state_st__bindgen_ty_1__bindgen_ty_1) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::<sha_state_st__bindgen_ty_1__bindgen_ty_1>())).h0 as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sha_state_st__bindgen_ty_1__bindgen_ty_1), + "::", + stringify!(h0) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::<sha_state_st__bindgen_ty_1__bindgen_ty_1>())).h1 as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sha_state_st__bindgen_ty_1__bindgen_ty_1), + "::", + stringify!(h1) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::<sha_state_st__bindgen_ty_1__bindgen_ty_1>())).h2 as *const _ + as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sha_state_st__bindgen_ty_1__bindgen_ty_1), + "::", + stringify!(h2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::<sha_state_st__bindgen_ty_1__bindgen_ty_1>())).h3 as *const _ + as usize + }, + 12usize, + concat!( + "Offset of field: ", + stringify!(sha_state_st__bindgen_ty_1__bindgen_ty_1), + "::", + stringify!(h3) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::<sha_state_st__bindgen_ty_1__bindgen_ty_1>())).h4 as *const _ + as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sha_state_st__bindgen_ty_1__bindgen_ty_1), + "::", + stringify!(h4) + ) + ); +} +#[test] +fn bindgen_test_layout_sha_state_st__bindgen_ty_1() { + assert_eq!( + ::std::mem::size_of::<sha_state_st__bindgen_ty_1>(), + 20usize, + concat!("Size of: ", stringify!(sha_state_st__bindgen_ty_1)) + ); + assert_eq!( + ::std::mem::align_of::<sha_state_st__bindgen_ty_1>(), + 4usize, + concat!("Alignment of ", stringify!(sha_state_st__bindgen_ty_1)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<sha_state_st__bindgen_ty_1>())).h as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sha_state_st__bindgen_ty_1), + "::", + stringify!(h) + ) + ); +} +#[test] +fn bindgen_test_layout_sha_state_st() { + assert_eq!( + ::std::mem::size_of::<sha_state_st>(), + 96usize, + concat!("Size of: ", stringify!(sha_state_st)) + ); + assert_eq!( + ::std::mem::align_of::<sha_state_st>(), + 4usize, + concat!("Alignment of ", stringify!(sha_state_st)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<sha_state_st>())).Nl as *const _ as usize }, + 20usize, + concat!( + "Offset of field: ", + stringify!(sha_state_st), + "::", + stringify!(Nl) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<sha_state_st>())).Nh as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sha_state_st), + "::", + stringify!(Nh) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<sha_state_st>())).data as *const _ as usize }, + 28usize, + concat!( + "Offset of field: ", + stringify!(sha_state_st), + "::", + stringify!(data) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<sha_state_st>())).num as *const _ as usize }, + 92usize, + concat!( + "Offset of field: ", + stringify!(sha_state_st), + "::", + stringify!(num) + ) + ); +} +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_SHA256_Init"] + pub fn SHA256_Init(sha: *mut SHA256_CTX) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_SHA256_Update"] + pub fn SHA256_Update( + sha: *mut SHA256_CTX, data: *const ::std::os::raw::c_void, len: usize, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_SHA256_Final"] + pub fn SHA256_Final(md: *mut u8, sha: *mut SHA256_CTX) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct sha256_state_st { + pub h: [u32; 8usize], + pub Nl: u32, + pub Nh: u32, + pub data: [u8; 64usize], + pub num: ::std::os::raw::c_uint, + pub md_len: ::std::os::raw::c_uint, +} +#[test] +fn bindgen_test_layout_sha256_state_st() { + assert_eq!( + ::std::mem::size_of::<sha256_state_st>(), + 112usize, + concat!("Size of: ", stringify!(sha256_state_st)) + ); + assert_eq!( + ::std::mem::align_of::<sha256_state_st>(), + 4usize, + concat!("Alignment of ", stringify!(sha256_state_st)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<sha256_state_st>())).h as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sha256_state_st), + "::", + stringify!(h) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<sha256_state_st>())).Nl as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sha256_state_st), + "::", + stringify!(Nl) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<sha256_state_st>())).Nh as *const _ as usize }, + 36usize, + concat!( + "Offset of field: ", + stringify!(sha256_state_st), + "::", + stringify!(Nh) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<sha256_state_st>())).data as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sha256_state_st), + "::", + stringify!(data) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<sha256_state_st>())).num as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sha256_state_st), + "::", + stringify!(num) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<sha256_state_st>())).md_len as *const _ as usize }, + 108usize, + concat!( + "Offset of field: ", + stringify!(sha256_state_st), + "::", + stringify!(md_len) + ) + ); +} +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_SHA384_Init"] + pub fn SHA384_Init(sha: *mut SHA512_CTX) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_SHA384_Update"] + pub fn SHA384_Update( + sha: *mut SHA512_CTX, data: *const ::std::os::raw::c_void, len: usize, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_SHA384_Final"] + pub fn SHA384_Final(md: *mut u8, sha: *mut SHA512_CTX) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_SHA512_Init"] + pub fn SHA512_Init(sha: *mut SHA512_CTX) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_SHA512_Update"] + pub fn SHA512_Update( + sha: *mut SHA512_CTX, data: *const ::std::os::raw::c_void, len: usize, + ) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "__RUST_MUNDANE_0_2_0_SHA512_Final"] + pub fn SHA512_Final(md: *mut u8, sha: *mut SHA512_CTX) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct sha512_state_st { + pub h: [u64; 8usize], + pub Nl: u64, + pub Nh: u64, + pub u: sha512_state_st__bindgen_ty_1, + pub num: ::std::os::raw::c_uint, + pub md_len: ::std::os::raw::c_uint, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union sha512_state_st__bindgen_ty_1 { + pub d: [u64; 16usize], + pub p: [u8; 128usize], + _bindgen_union_align: [u64; 16usize], +} +#[test] +fn bindgen_test_layout_sha512_state_st__bindgen_ty_1() { + assert_eq!( + ::std::mem::size_of::<sha512_state_st__bindgen_ty_1>(), + 128usize, + concat!("Size of: ", stringify!(sha512_state_st__bindgen_ty_1)) + ); + assert_eq!( + ::std::mem::align_of::<sha512_state_st__bindgen_ty_1>(), + 8usize, + concat!("Alignment of ", stringify!(sha512_state_st__bindgen_ty_1)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<sha512_state_st__bindgen_ty_1>())).d as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sha512_state_st__bindgen_ty_1), + "::", + stringify!(d) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<sha512_state_st__bindgen_ty_1>())).p as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sha512_state_st__bindgen_ty_1), + "::", + stringify!(p) + ) + ); +} +#[test] +fn bindgen_test_layout_sha512_state_st() { + assert_eq!( + ::std::mem::size_of::<sha512_state_st>(), + 216usize, + concat!("Size of: ", stringify!(sha512_state_st)) + ); + assert_eq!( + ::std::mem::align_of::<sha512_state_st>(), + 8usize, + concat!("Alignment of ", stringify!(sha512_state_st)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<sha512_state_st>())).h as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sha512_state_st), + "::", + stringify!(h) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<sha512_state_st>())).Nl as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sha512_state_st), + "::", + stringify!(Nl) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<sha512_state_st>())).Nh as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sha512_state_st), + "::", + stringify!(Nh) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<sha512_state_st>())).u as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sha512_state_st), + "::", + stringify!(u) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<sha512_state_st>())).num as *const _ as usize }, + 208usize, + concat!( + "Offset of field: ", + stringify!(sha512_state_st), + "::", + stringify!(num) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<sha512_state_st>())).md_len as *const _ as usize }, + 212usize, + concat!( + "Offset of field: ", + stringify!(sha512_state_st), + "::", + stringify!(md_len) + ) + ); +}
diff --git a/boringssl/test_symbol_conflict.sh b/boringssl/test_symbol_conflict.sh new file mode 100755 index 0000000..15a0f14 --- /dev/null +++ b/boringssl/test_symbol_conflict.sh
@@ -0,0 +1,238 @@ +#!/bin/bash + +# Copyright 2018 Google LLC +# +# Use of this source code is governed by an MIT-style +# license that can be found in the LICENSE file or at +# https://opensource.org/licenses/MIT. + +# This script tests that a build with multiple versions of the mundane crate in +# the same build graph works properly. It performs the following steps: +# - Create a temporary directory +# - Create two copies of mundane - mundane-v1, and mundane-v2 - which directly +# expose the boringssl::ffi module so that dependent crates can access the raw +# symbols +# - Create two crates, one depending on mundane-v1, and one on mundane-v2, each +# of which exposes all of the BoringSSL symbols from mundane +# - Create a top-level program which depends on both of these crates +# - Have the top-level program's main call all of the mundane functions from +# each of the crates +# - Produce a release build, which forces linking, to make sure that linking +# these two versions of the library at the same time works properly + +set -e + +# the directory this script lives in +readonly SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +CRATE_ROOT="${SCRIPT_DIR}/.." + +TMP="$(mktemp -d)" +cd "$TMP" + +# NOTE: The -L means to follow symlinks +cp -LR "$CRATE_ROOT" mundane-v1 +cp -LR "$CRATE_ROOT" mundane-v2 +echo "$TMP" + +# +# Make mundane crates +# + +# Update the Cargo.toml versions and names in place to be distinct +sed -i '' -e 's/^name =.*/name = "mundane-v1"/' mundane-v1/Cargo.toml +sed -i '' -e 's/^version =.*/version = "1.0.0"/' mundane-v1/Cargo.toml +sed -i '' -e 's/^name =.*/name = "mundane-v2"/' mundane-v2/Cargo.toml +sed -i '' -e 's/^version =.*/version = "2.0.0"/' mundane-v2/Cargo.toml + +# Update the link directive to use the right version number +sed -i '' -e 's/#[link(name = "crypto_[0-9]*_[0-9]*_[0-9]*")]/#[link(name = "crypto_1_0_0")]/' mundane-v1/boringssl/boringssl.rs +sed -i '' -e 's/#[link(name = "crypto_[0-9]*_[0-9]*_[0-9]*")]/#[link(name = "crypto_2_0_0")]/' mundane-v2/boringssl/boringssl.rs +# Update the link_name directives to use the right version number +sed -i '' -e 's/__RUST_MUNDANE_[0-9]*_[0-9]*_[0-9]*_/__RUST_MUNDANE_1_0_0_/' mundane-v1/boringssl/boringssl.rs +sed -i '' -e 's/__RUST_MUNDANE_[0-9]*_[0-9]*_[0-9]*_/__RUST_MUNDANE_2_0_0_/' mundane-v2/boringssl/boringssl.rs +# Mark the ffi module as public +sed -i '' -e 's/^mod ffi;$/pub mod ffi;/' mundane-v1/src/boringssl/mod.rs +sed -i '' -e 's/^mod ffi;$/pub mod ffi;/' mundane-v2/src/boringssl/mod.rs +# Make mundane directly expose the ffi module +echo "pub use boringssl::ffi;" >> mundane-v1/src/lib.rs +echo "pub use boringssl::ffi;" >> mundane-v2/src/lib.rs + +# +# Make crates which depend on mundane +# + +# Usage: make_crate <crate name> <dep name> +function make_crate { + CRATE_NAME="$1" + DEP_NAME="$2" + DEP_NAME_RS="$(echo ${DEP_NAME} | tr - _)" + + mkdir "$CRATE_NAME" + mkdir "${CRATE_NAME}/src" + # Re-export all symbols from mundane + cat >> "${CRATE_NAME}/src/lib.rs" <<EOF +extern crate ${DEP_NAME_RS}; + +pub use ${DEP_NAME_RS}::ffi::*; +EOF + + cat >> "${CRATE_NAME}/Cargo.toml" <<EOF +[package] +name = "${CRATE_NAME}" +version = "0.0.0" + +[dependencies] +${DEP_NAME} = { path = "../${DEP_NAME}" } +EOF +} + +make_crate depends-mundane-v1 mundane-v1 +make_crate depends-mundane-v2 mundane-v2 + +# +# Make top-level crate +# + +cat >> Cargo.toml <<EOF +[package] +name = "mundane-version-test" +version = "0.0.0" + +[dependencies] +depends-mundane-v1 = { path = "./depends-mundane-v1" } +depends-mundane-v2 = { path = "./depends-mundane-v2" } +EOF + +# The body of main() is generated with the following scripts: +# rg -U 'extern "C" \{\n[^\n]*\n pub fn [0-9A-Za-z_]*([^)]*)' boringssl.rs | grep '^ *pub fn' | sed -e 's/.*pub fn \([^(]*\).*/println!("{:?}", depends_mundane_v1::\1 as *const ());/' +# rg -U 'extern "C" \{\n[^\n]*\n pub fn [0-9A-Za-z_]*([^)]*)' boringssl.rs | grep '^ *pub fn' | sed -e 's/.*pub fn \([^(]*\).*/println!("{:?}", depends_mundane_v2::\1 as *const ());/' + +mkdir src +cat >> src/main.rs <<EOF +extern crate depends_mundane_v1; +extern crate depends_mundane_v2; + +fn main() { +println!("{:?}", depends_mundane_v1::ERR_print_errors_cb as *const ()); +println!("{:?}", depends_mundane_v1::CBS_init as *const ()); +println!("{:?}", depends_mundane_v1::CBS_len as *const ()); +println!("{:?}", depends_mundane_v1::CBB_init as *const ()); +println!("{:?}", depends_mundane_v1::CBB_cleanup as *const ()); +println!("{:?}", depends_mundane_v1::CBB_data as *const ()); +println!("{:?}", depends_mundane_v1::CBB_len as *const ()); +println!("{:?}", depends_mundane_v1::ED25519_keypair as *const ()); +println!("{:?}", depends_mundane_v1::ED25519_sign as *const ()); +println!("{:?}", depends_mundane_v1::ED25519_verify as *const ()); +println!("{:?}", depends_mundane_v1::ED25519_keypair_from_seed as *const ()); +println!("{:?}", depends_mundane_v1::EVP_sha1 as *const ()); +println!("{:?}", depends_mundane_v1::EVP_sha256 as *const ()); +println!("{:?}", depends_mundane_v1::EVP_sha384 as *const ()); +println!("{:?}", depends_mundane_v1::EVP_sha512 as *const ()); +println!("{:?}", depends_mundane_v1::EC_GROUP_new_by_curve_name as *const ()); +println!("{:?}", depends_mundane_v1::EC_GROUP_get_curve_name as *const ()); +println!("{:?}", depends_mundane_v1::EC_curve_nid2nist as *const ()); +println!("{:?}", depends_mundane_v1::EC_KEY_new as *const ()); +println!("{:?}", depends_mundane_v1::EC_KEY_free as *const ()); +println!("{:?}", depends_mundane_v1::EC_KEY_up_ref as *const ()); +println!("{:?}", depends_mundane_v1::EC_KEY_get0_group as *const ()); +println!("{:?}", depends_mundane_v1::EC_KEY_set_group as *const ()); +println!("{:?}", depends_mundane_v1::EC_KEY_generate_key as *const ()); +println!("{:?}", depends_mundane_v1::EC_KEY_parse_private_key as *const ()); +println!("{:?}", depends_mundane_v1::EC_KEY_marshal_private_key as *const ()); +println!("{:?}", depends_mundane_v1::ECDSA_sign as *const ()); +println!("{:?}", depends_mundane_v1::ECDSA_verify as *const ()); +println!("{:?}", depends_mundane_v1::ECDSA_size as *const ()); +println!("{:?}", depends_mundane_v1::EVP_PKEY_new as *const ()); +println!("{:?}", depends_mundane_v1::EVP_PKEY_free as *const ()); +println!("{:?}", depends_mundane_v1::EVP_PKEY_up_ref as *const ()); +println!("{:?}", depends_mundane_v1::EVP_PKEY_assign_EC_KEY as *const ()); +println!("{:?}", depends_mundane_v1::EVP_PKEY_get1_EC_KEY as *const ()); +println!("{:?}", depends_mundane_v1::EVP_parse_public_key as *const ()); +println!("{:?}", depends_mundane_v1::EVP_marshal_public_key as *const ()); +println!("{:?}", depends_mundane_v1::PKCS5_PBKDF2_HMAC as *const ()); +println!("{:?}", depends_mundane_v1::EVP_PBE_scrypt as *const ()); +println!("{:?}", depends_mundane_v1::HMAC_CTX_init as *const ()); +println!("{:?}", depends_mundane_v1::HMAC_CTX_cleanup as *const ()); +println!("{:?}", depends_mundane_v1::HMAC_Init_ex as *const ()); +println!("{:?}", depends_mundane_v1::HMAC_Update as *const ()); +println!("{:?}", depends_mundane_v1::HMAC_Final as *const ()); +println!("{:?}", depends_mundane_v1::HMAC_size as *const ()); +println!("{:?}", depends_mundane_v1::CRYPTO_memcmp as *const ()); +println!("{:?}", depends_mundane_v1::RAND_bytes as *const ()); +println!("{:?}", depends_mundane_v1::SHA1_Init as *const ()); +println!("{:?}", depends_mundane_v1::SHA1_Update as *const ()); +println!("{:?}", depends_mundane_v1::SHA1_Final as *const ()); +println!("{:?}", depends_mundane_v1::SHA256_Init as *const ()); +println!("{:?}", depends_mundane_v1::SHA256_Update as *const ()); +println!("{:?}", depends_mundane_v1::SHA256_Final as *const ()); +println!("{:?}", depends_mundane_v1::SHA384_Init as *const ()); +println!("{:?}", depends_mundane_v1::SHA384_Update as *const ()); +println!("{:?}", depends_mundane_v1::SHA384_Final as *const ()); +println!("{:?}", depends_mundane_v1::SHA512_Init as *const ()); +println!("{:?}", depends_mundane_v1::SHA512_Update as *const ()); +println!("{:?}", depends_mundane_v1::SHA512_Final as *const ()); +println!("{:?}", depends_mundane_v2::ERR_print_errors_cb as *const ()); +println!("{:?}", depends_mundane_v2::CBS_init as *const ()); +println!("{:?}", depends_mundane_v2::CBS_len as *const ()); +println!("{:?}", depends_mundane_v2::CBB_init as *const ()); +println!("{:?}", depends_mundane_v2::CBB_cleanup as *const ()); +println!("{:?}", depends_mundane_v2::CBB_data as *const ()); +println!("{:?}", depends_mundane_v2::CBB_len as *const ()); +println!("{:?}", depends_mundane_v2::ED25519_keypair as *const ()); +println!("{:?}", depends_mundane_v2::ED25519_sign as *const ()); +println!("{:?}", depends_mundane_v2::ED25519_verify as *const ()); +println!("{:?}", depends_mundane_v2::ED25519_keypair_from_seed as *const ()); +println!("{:?}", depends_mundane_v2::EVP_sha1 as *const ()); +println!("{:?}", depends_mundane_v2::EVP_sha256 as *const ()); +println!("{:?}", depends_mundane_v2::EVP_sha384 as *const ()); +println!("{:?}", depends_mundane_v2::EVP_sha512 as *const ()); +println!("{:?}", depends_mundane_v2::EC_GROUP_new_by_curve_name as *const ()); +println!("{:?}", depends_mundane_v2::EC_GROUP_get_curve_name as *const ()); +println!("{:?}", depends_mundane_v2::EC_curve_nid2nist as *const ()); +println!("{:?}", depends_mundane_v2::EC_KEY_new as *const ()); +println!("{:?}", depends_mundane_v2::EC_KEY_free as *const ()); +println!("{:?}", depends_mundane_v2::EC_KEY_up_ref as *const ()); +println!("{:?}", depends_mundane_v2::EC_KEY_get0_group as *const ()); +println!("{:?}", depends_mundane_v2::EC_KEY_set_group as *const ()); +println!("{:?}", depends_mundane_v2::EC_KEY_generate_key as *const ()); +println!("{:?}", depends_mundane_v2::EC_KEY_parse_private_key as *const ()); +println!("{:?}", depends_mundane_v2::EC_KEY_marshal_private_key as *const ()); +println!("{:?}", depends_mundane_v2::ECDSA_sign as *const ()); +println!("{:?}", depends_mundane_v2::ECDSA_verify as *const ()); +println!("{:?}", depends_mundane_v2::ECDSA_size as *const ()); +println!("{:?}", depends_mundane_v2::EVP_PKEY_new as *const ()); +println!("{:?}", depends_mundane_v2::EVP_PKEY_free as *const ()); +println!("{:?}", depends_mundane_v2::EVP_PKEY_up_ref as *const ()); +println!("{:?}", depends_mundane_v2::EVP_PKEY_assign_EC_KEY as *const ()); +println!("{:?}", depends_mundane_v2::EVP_PKEY_get1_EC_KEY as *const ()); +println!("{:?}", depends_mundane_v2::EVP_parse_public_key as *const ()); +println!("{:?}", depends_mundane_v2::EVP_marshal_public_key as *const ()); +println!("{:?}", depends_mundane_v2::PKCS5_PBKDF2_HMAC as *const ()); +println!("{:?}", depends_mundane_v2::EVP_PBE_scrypt as *const ()); +println!("{:?}", depends_mundane_v2::HMAC_CTX_init as *const ()); +println!("{:?}", depends_mundane_v2::HMAC_CTX_cleanup as *const ()); +println!("{:?}", depends_mundane_v2::HMAC_Init_ex as *const ()); +println!("{:?}", depends_mundane_v2::HMAC_Update as *const ()); +println!("{:?}", depends_mundane_v2::HMAC_Final as *const ()); +println!("{:?}", depends_mundane_v2::HMAC_size as *const ()); +println!("{:?}", depends_mundane_v2::CRYPTO_memcmp as *const ()); +println!("{:?}", depends_mundane_v2::RAND_bytes as *const ()); +println!("{:?}", depends_mundane_v2::SHA1_Init as *const ()); +println!("{:?}", depends_mundane_v2::SHA1_Update as *const ()); +println!("{:?}", depends_mundane_v2::SHA1_Final as *const ()); +println!("{:?}", depends_mundane_v2::SHA256_Init as *const ()); +println!("{:?}", depends_mundane_v2::SHA256_Update as *const ()); +println!("{:?}", depends_mundane_v2::SHA256_Final as *const ()); +println!("{:?}", depends_mundane_v2::SHA384_Init as *const ()); +println!("{:?}", depends_mundane_v2::SHA384_Update as *const ()); +println!("{:?}", depends_mundane_v2::SHA384_Final as *const ()); +println!("{:?}", depends_mundane_v2::SHA512_Init as *const ()); +println!("{:?}", depends_mundane_v2::SHA512_Update as *const ()); +println!("{:?}", depends_mundane_v2::SHA512_Final as *const ()); +} +EOF + +cargo build --release + +cd - +rm -rf "$TMP" \ No newline at end of file
diff --git a/build.rs b/build.rs new file mode 100644 index 0000000..6662e83 --- /dev/null +++ b/build.rs
@@ -0,0 +1,256 @@ +// Copyright 2018 Google LLC +// +// Use of this source code is governed by an MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT. + +// This build script is responsible for building BoringSSL with the appropriate +// symbol prefix. See boringssl/README.md for details. + +use std::env; +use std::fs; +use std::process::{Command, Stdio}; + +// Relative to CARGO_MANIFEST_DIR +const BORINGSSL_SRC: &str = "boringssl/boringssl"; + +// Relative to OUT_DIR +const BUILD_DIR_1: &str = "boringssl/build_1"; +const BUILD_DIR_2: &str = "boringssl/build_2"; +const SYMBOL_FILE: &str = "boringssl/symbols.txt"; + +fn env(name: &str) -> String { + let var = env::var(name).expect(&format!("missing required environment variable {}", name)); + println!("cargo:rerun-if-env-changed={}", var); + var +} + +fn main() { + validate_dependencies(); + + let manifest_dir = env("CARGO_MANIFEST_DIR"); + let abs_boringssl_src = format!("{}/{}", manifest_dir, BORINGSSL_SRC); + + let out_dir = env("OUT_DIR"); + let abs_build_dir_1 = format!("{}/{}", out_dir, BUILD_DIR_1); + let abs_build_dir_2 = format!("{}/{}", out_dir, BUILD_DIR_2); + let abs_symbol_file = format!("{}/{}", out_dir, SYMBOL_FILE); + + fs::create_dir_all(&abs_build_dir_1).expect("failed to create first build directory"); + fs::create_dir_all(&abs_build_dir_2).expect("failed to create second build directory"); + + let major = env("CARGO_PKG_VERSION_MAJOR"); + let minor = env("CARGO_PKG_VERSION_MINOR"); + let patch = env("CARGO_PKG_VERSION_PATCH"); + let version_string = format!("{}_{}_{}", major, minor, patch); + let prefix = format!("__RUST_MUNDANE_{}", version_string); + let cmake_version_flag = format!("-DBORINGSSL_PREFIX={}", prefix); + + let built_with = built_with(&abs_build_dir_1); + let have_ninja = have_ninja(); + let build = |build_dir, flags: &[&str]| { + fn with_ninja<'a, 'b>(flags: &'a [&'b str]) -> Vec<&'b str> { + let mut flags = flags.to_vec(); + flags.push("-GNinja"); + flags + } + + env::set_current_dir(build_dir).expect("failed to cd to build directory"); + // If we've already run a build, then we need to build with the same + // tool the second time around, or cmake will complain. There's + // technically a chance that, after having built, the user uninstalled + // the build tool, but that's unlikely enough that it's not worth + // introducing the complexity necessary to support that use case. + match built_with { + Some(BuildSystem::Ninja) => { + run("cmake", &with_ninja(flags)); + run("ninja", &["crypto"]); + } + Some(BuildSystem::Make) => { + run("cmake", flags); + run("make", &["crypto"]); + } + None => { + if have_ninja { + run("cmake", &with_ninja(flags)); + run("ninja", &["crypto"]); + } else { + run("cmake", flags); + run("make", &["crypto"]); + } + } + } + }; + + build(&abs_build_dir_1, &[&abs_boringssl_src]); + + // 'go run' requires that we're cd'd into a subdirectory of the Go module + // root in order for Go modules to work + let orig = env::current_dir().expect("could not get current directory"); + env::set_current_dir(&format!("{}/util", &abs_boringssl_src)) + .expect("could not set current directory"); + run( + "go", + &[ + "run", + "read_symbols.go", + "-out", + &abs_symbol_file, + &format!("{}/crypto/libcrypto.a", &abs_build_dir_1), + ], + ); + env::set_current_dir(orig).expect("could not set current directory"); + + build( + &abs_build_dir_2, + &[ + &abs_boringssl_src, + &cmake_version_flag, + "-DBORINGSSL_PREFIX_SYMBOLS=../symbols.txt", + ], + ); + + // NOTE(joshlf): We symlink rather than renaming so that the BoringSSL build + // system won't notice that libcrypto.a is gone and spuriously attempt to + // rebuild. + #[cfg(unix)] + let res = std::os::unix::fs::symlink( + format!("{}/crypto/libcrypto.a", abs_build_dir_2), + format!("{}/crypto/libcrypto_{}.a", abs_build_dir_2, version_string), + ); + #[cfg(windows)] + let res = std::os::windows::fs::symlink_file( + format!("{}/crypto/libcrypto.a", abs_build_dir_2), + format!("{}/crypto/libcrypto_{}.a", abs_build_dir_2, version_string), + ); + // If symlinking isn't available, we fall back to renaming. + #[cfg(not(any(unix, windows)))] + let res = fs::rename( + format!("{}/crypto/libcrypto.a", abs_build_dir_2), + format!("{}/crypto/libcrypto_{}.a", abs_build_dir_2, version_string), + ); + + if let Err(err) = res { + // If the error is an AlreadyExists error, that just means we've already + // compiled before. Renaming to an existing file works without error, so + // it's OK that our panic message only mentions symlinking. + if err.kind() != std::io::ErrorKind::AlreadyExists { + panic!("could not symlink to libcrypto.a: {}", err) + } + } + + println!("cargo:rustc-link-search=native={}/crypto", abs_build_dir_2); +} + +// Validates that dependencies which we invoke directly are present, or panics +// with an error message. Does not check for dependencies of BoringSSL's build +// system. +fn validate_dependencies() { + let go = have_go(); + let cmake = have_cmake(); + let ninja = have_ninja(); + let make = have_make(); + + if !go { + panic!( + " + +Missing build dependency Go (1.11 or higher). + +" + ); + } + if !cmake { + panic!( + " + +Missing build dependency CMake. + +" + ); + } + if cfg!(windows) && !ninja { + panic!( + " + +Building on Windows requires the Ninja tool. See https://ninja-build.org/. + +" + ); + } + if !make && !ninja { + panic!( + " + +Building requires either Make or Ninja (https://ninja-build.org/). + +" + ); + } +} + +// Runs a command and panic if it fails. +fn run(cmd: &str, args: &[&str]) { + let output = Command::new(cmd) + .args(args) + .stdout(Stdio::inherit()) + .stderr(Stdio::inherit()) + .output() + .expect(&format!("failed to invoke {}", cmd)); + if !output.status.success() { + panic!("{} failed with status {}", cmd, output.status); + } +} + +// Is Go installed? +fn have_go() -> bool { + have("go", &["version"]) +} + +// Is CMake installed? +fn have_cmake() -> bool { + have("cmake", &["--version"]) +} + +// Is Ninja installed? +fn have_ninja() -> bool { + have("ninja", &["--version"]) +} + +// Is Make installed? +fn have_make() -> bool { + have("make", &["--version"]) +} + +// Checks whether a program is installed by running it. +// +// `have` checks whether `name` is installed by running it with the provided +// `args`. It must exist successfully. +fn have(name: &str, args: &[&str]) -> bool { + Command::new(name) + .args(args) + .output() + .map(|output| output.status.success()) + .unwrap_or(false) +} + +enum BuildSystem { + Ninja, + Make, +} + +// Checks which build tool was used for the previous build. +fn built_with(abs_dir: &str) -> Option<BuildSystem> { + let is_file = |file| { + fs::metadata(format!("{}/{}", abs_dir, file)) + .map(|meta| meta.is_file()) + .unwrap_or(false) + }; + if is_file("build.ninja") { + Some(BuildSystem::Ninja) + } else if is_file("Makefile") { + Some(BuildSystem::Make) + } else { + None + } +}
diff --git a/src/boringssl/abort.rs b/src/boringssl/abort.rs new file mode 100644 index 0000000..d422c91 --- /dev/null +++ b/src/boringssl/abort.rs
@@ -0,0 +1,200 @@ +// Copyright 2018 Google LLC +// +// Use of this source code is governed by an MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT. + +//! Macros and functions that abort instead of unwinding. +//! +//! Writing `unsafe` code which retains memory safety in the face of unwinding +//! is [notoriously +//! difficult](https://doc.rust-lang.org/nightly/nomicon/exception-safety.html). +//! This module provides panic-related macros and functions that abort rather +//! than unwind. These are used in place of unwinding-based macros and functions +//! so that we can avoid the high probability of us getting unwind-safe code +//! wrong. + +use std::fmt::Debug; + +macro_rules! assert_abort { + ($cond:expr) => ({ + let cond = $cond; + let cond_str = stringify!($cond); + assert_abort!(cond, "{}", cond_str); + }); + ($cond:expr,) => ({ + assert_abort!($cond); + }); + ($cond:expr, $msg:expr, $($arg:tt)*) => ({ + if !($cond) { + panic_abort!(concat!("assertion failed: ", $msg), $($arg)*); + } + }); +} + +macro_rules! assert_abort_eq { + ($left:expr, $right:expr) => ({ + match (&$left, &$right) { + (left_val, right_val) => { + if !(*left_val == *right_val) { + panic_abort!(r#"assertion failed: `(left == right)` + left: `{:?}`, + right: `{:?}`"#, left_val, right_val) + } + } + } + }); + ($left:expr, $right:expr,) => ({ + assert_eq!($left, $right) + }); + ($left:expr, $right:expr, $($arg:tt)+) => ({ + match (&($left), &($right)) { + (left_val, right_val) => { + if !(*left_val == *right_val) { + panic_abort!(r#"assertion failed: `(left == right)` + left: `{:?}`, + right: `{:?}`: {}"#, left_val, right_val, + format_args!($($arg)+)) + } + } + } + }); +} + +#[allow(unused)] +macro_rules! unimplemented_abort { + () => {{ + panic_abort!("not yet implemented") + }}; +} + +macro_rules! unreachable_abort { + () => {{ + panic_abort!("internal error: entered unreachable code") + }}; +} + +macro_rules! panic_abort { + () => ({ + panic_abort!("explicit panic") + }); + ($msg:expr) => ({ + eprintln!("{}", $msg); + ::std::process::abort(); + }); + ($msg:expr,) => ({ + panic_abort!($msg) + }); + ($fmt:expr, $($arg:tt)+) => ({ + panic_abort!(format!($fmt, $($arg)+)); + }); +} + +// Redefine normal panic/assert macros so their use will cause a compiler error. + +#[allow(unused)] +macro_rules! panic { + ($($x:tt)*) => { + compile_error!("use panic_abort! instead of panic! in boringssl module") + }; +} + +#[allow(unused)] +macro_rules! assert { + ($($x:tt)*) => { + compile_error!("use assert_abort! instead of assert! in boringssl module") + }; +} + +#[allow(unused)] +macro_rules! assert_eq { + ($($x:tt)*) => { + compile_error!("use assert_abort_eq! instead of assert_eq! in boringssl module") + }; +} + +#[allow(unused)] +macro_rules! assert_ne { + ($($x:tt)*) => { + compile_error!("use assert_abort_ne! instead of assert_ne! in boringssl module") + }; +} + +#[allow(unused)] +macro_rules! unimplemented { + ($($x:tt)*) => { + compile_error!("use unimplemented_abort! instead of unimplemented! in boringssl module") + }; +} + +#[allow(unused)] +macro_rules! unreachable { + ($($x:tt)*) => { + compile_error!("use unreachable_abort! instead of unreachable! in boringssl module") + }; +} + +// unwrap and expect + +// TODO(joshlf): Is there a way (maybe with clippy) that we can cause warnings +// or errors if this module ever uses unwrap or expect? + +pub trait UnwrapAbort { + type Item; + + fn unwrap_abort(self) -> Self::Item; + fn expect_abort(self, msg: &str) -> Self::Item; +} + +// The implementations for Option and Result are adapted from the Rust standard library. +impl<T> UnwrapAbort for Option<T> { + type Item = T; + + fn unwrap_abort(self) -> T { + match self { + Some(val) => val, + None => panic_abort!("called `Option::unwrap_abort()` on a `None` value"), + } + } + + fn expect_abort(self, msg: &str) -> T { + // This is a separate function to reduce the code size of alloc_expect itself + #[inline(never)] + #[cold] + fn failed(msg: &str) -> ! { + panic_abort!("{}", msg); + } + + match self { + Some(val) => val, + None => failed(msg), + } + } +} + +impl<T, E: Debug> UnwrapAbort for Result<T, E> { + type Item = T; + + fn unwrap_abort(self) -> T { + match self { + Ok(val) => val, + Err(err) => { + result_unwrap_failed("called `Result::unwrap_abort()` on an `Err` value", err) + } + } + } + + fn expect_abort(self, msg: &str) -> T { + match self { + Ok(val) => val, + Err(err) => result_unwrap_failed(msg, err), + } + } +} + +// This is a separate function to reduce the code size of alloc_{expect,unwrap} +#[inline(never)] +#[cold] +fn result_unwrap_failed<E: Debug>(msg: &str, err: E) -> ! { + panic_abort!("{}: {:?}", msg, err) +}
diff --git a/src/boringssl/mod.rs b/src/boringssl/mod.rs new file mode 100644 index 0000000..2327577 --- /dev/null +++ b/src/boringssl/mod.rs
@@ -0,0 +1,743 @@ +// Copyright 2018 Google LLC +// +// Use of this source code is governed by an MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT. + +//! The BoringSSL API. +//! +//! This module provides a safe access to the BoringSSL API. +//! +//! It accomplishes this using the following structure: +//! - The internal `raw` module provides nearly-raw access to the BoringSSL API. +//! For each function in the BoringSSL API, it exposes an equivalent Rust +//! function which performs error checking. Functions which return pointers +//! return `Result<NonNull<T>, BoringError>`, functions which return status +//! codes return `Result<(), BoringError>`, etc. This API makes it less likely +//! to accidentally forget to check for null pointers or error status codes. +//! - The internal `wrapper` module provides types which wrap C objects and +//! handle many of the details of their lifecycles. These include +//! `CStackWrapper`, which handles initializing and destructing +//! stack-allocated C objects; `CHeapWrapper`, which is analogous to Rust's +//! `Box` or `Rc`, and handles allocation, reference counting, and freeing; +//! and `CRef`, which is analogous to a Rust reference. +//! - This module builds on top of the `raw` and `wrapper` modules to provide a +//! safe API. This allows us to `#![forbid(unsafe_code)]` in the rest of the +//! crate, which in turn means that this is the only module whose memory +//! safety needs to be manually verified. +//! +//! # Usage +//! +//! Each type, `T`, from the BoringSSL API is exposed as either a +//! `CStackWrapper<T>`, a `CHeapWrapper<T>`, or a `CRef<T>`. Each function from +//! the BoringSSL API which operates on a particular type is exposed as a method +//! on the wrapped version of that type. For example, the BoringSSL `CBS_len` +//! function operates on a `CBS`; we provide the `cbs_len` method on the +//! `CStackWrapper<CBS>` type. While BoringSSL functions that operate on a +//! particular type take the form `TYPE_method`, the Rust equivalents are all +//! lower-case - `type_method`. +//! +//! Some functions which do not make sense as methods are exposed as bare +//! functions. For example, the BoringSSL `ECDSA_sign` function is exposed as a +//! bare function as `ecdsa_sign`. +//! +//! Types which can be constructed without arguments implement `Default`. Types +//! which require arguments to be constructed provide associated functions which +//! take those arguments and return a new instance of that type. For example, +//! the `CHeapWrapper<EC_KEY>::ec_key_parse_private_key` function parses a +//! private key from an input stream and returns a new `CHeapWrapper<EC_KEY>`. +//! +//! # API Guidelines +//! +//! This module is meant to be as close as possible to a direct set of FFI +//! bindings while still providing a safe API. While memory safety is handled +//! internally, and certain error conditions which could affect memory safety +//! are checked internally (and cause the process to abort if they fail), most +//! errors are returned from the API, as they are considered business logic, +//! which is outside the scope of this module. + +// NOTES on safety requirements of the BoringSSL API: +// - Though it may not be explicitly documented, calling methods on uinitialized +// values is UB. Remember, this is C! Always initialize (usually via XXX_init +// or a similarly-named function) before calling any methods or functions. +// - Any BoringSSL documentation that says "x property must hold" means that, if +// that property doesn't hold, it may cause UB - you are not guaranteed that +// it will be detected and an error will be returned. + +// NOTE(joshlf): It's important to define this module before the abort module, +// or else all of the assertions that are auto-generated by bindgen would result +// in compilation errors. +#[path = "../../boringssl/boringssl.rs"] +mod ffi; +#[macro_use] +mod abort; +#[macro_use] +mod wrapper; +mod raw; + +// C types +pub use boringssl::ffi::{CBB, CBS, EC_GROUP, EC_KEY, EVP_MD, EVP_PKEY, HMAC_CTX, SHA256_CTX, + SHA512_CTX, SHA_CTX}; +// C constants +pub use boringssl::ffi::{NID_X9_62_prime256v1, NID_secp384r1, NID_secp521r1, + ED25519_PRIVATE_KEY_LEN, ED25519_PUBLIC_KEY_LEN, ED25519_SIGNATURE_LEN, + SHA256_DIGEST_LENGTH, SHA384_DIGEST_LENGTH, SHA512_DIGEST_LENGTH, + SHA_DIGEST_LENGTH}; +// wrapper types +pub use boringssl::wrapper::{CHeapWrapper, CRef, CStackWrapper}; + +use std::ffi::CStr; +use std::fmt::{self, Debug, Display, Formatter}; +use std::num::NonZeroUsize; +use std::os::raw::{c_char, c_int, c_uint, c_void}; +use std::{mem, ptr, slice}; + +use boringssl::abort::UnwrapAbort; +use boringssl::raw::{CBB_data, CBB_init, CBB_len, CBS_init, CBS_len, CRYPTO_memcmp, ECDSA_sign, + ECDSA_size, ECDSA_verify, EC_GROUP_get_curve_name, + EC_GROUP_new_by_curve_name, EC_KEY_generate_key, EC_KEY_get0_group, + EC_KEY_marshal_private_key, EC_KEY_parse_private_key, EC_KEY_set_group, + EC_curve_nid2nist, ED25519_keypair, ED25519_keypair_from_seed, ED25519_sign, + ED25519_verify, ERR_print_errors_cb, EVP_PBE_scrypt, EVP_PKEY_assign_EC_KEY, + EVP_PKEY_get1_EC_KEY, EVP_marshal_public_key, EVP_parse_public_key, + HMAC_CTX_init, HMAC_Final, HMAC_Init_ex, HMAC_Update, HMAC_size, RAND_bytes, + SHA384_Init}; + +impl CStackWrapper<CBB> { + /// Creates a new `CBB` and initializes it with `CBB_init`. + /// + /// `cbb_new` can only fail due to OOM. + #[must_use] + pub fn cbb_new(initial_capacity: usize) -> Result<CStackWrapper<CBB>, BoringError> { + unsafe { + let mut cbb = mem::uninitialized(); + CBB_init(&mut cbb, initial_capacity)?; + Ok(CStackWrapper::new(cbb)) + } + } + + /// Invokes a callback on the contents of a `CBB`. + /// + /// `cbb_with_data` accepts a callback, and invokes that callback, passing a + /// slice of the current contents of this `CBB`. + #[must_use] + pub fn cbb_with_data<O, F: Fn(&[u8]) -> O>(&self, with_data: F) -> O { + unsafe { + // NOTE: The return value of CBB_data is only valid until the next + // operation on the CBB. This method is safe because the slice + // reference cannot outlive this function body, and thus cannot live + // beyond another method call that could invalidate the buffer. + let len = CBB_len(self.as_const()); + if len == 0 { + // If len is 0, then CBB_data could technically return a null + // pointer. Constructing a slice from a null pointer is likely + // invalid, so we do this instead. + with_data(&[]) + } else { + // Since the length is non-zero, CBB_data should not return a + // null pointer. + let ptr = CBB_data(self.as_const()).unwrap_abort(); + // TODO(joshlf): Can with_data use this to smuggle out the + // reference, outliving the lifetime of self? + with_data(slice::from_raw_parts(ptr.as_ptr(), len)) + } + } + } +} + +impl CStackWrapper<CBS> { + /// The `CBS_len` function. + #[must_use] + pub fn cbs_len(&self) -> usize { + unsafe { CBS_len(self.as_const()) } + } + + /// Invokes a callback on a temporary `CBS`. + /// + /// `cbs_with_temp_buffer` constructs a `CBS` from the provided byte slice, + /// and invokes a callback on the `CBS`. The `CBS` is destructed before + /// `cbs_with_temp_buffer` returns. + // TODO(joshlf): Holdover until we figure out how to put lifetimes in CStackWrappers. + #[must_use] + pub fn cbs_with_temp_buffer<O, F: Fn(&mut CStackWrapper<CBS>) -> O>( + bytes: &[u8], with_cbs: F, + ) -> O { + unsafe { + let mut cbs = mem::uninitialized(); + CBS_init(&mut cbs, bytes.as_ptr(), bytes.len()); + let mut cbs = CStackWrapper::new(cbs); + with_cbs(&mut cbs) + } + } +} + +impl CRef<'static, EC_GROUP> { + /// The `EC_GROUP_new_by_curve_name` function. + #[must_use] + pub fn ec_group_new_by_curve_name(nid: c_int) -> Result<CRef<'static, EC_GROUP>, BoringError> { + unsafe { Ok(CRef::new(EC_GROUP_new_by_curve_name(nid)?)) } + } +} + +impl<'a> CRef<'a, EC_GROUP> { + /// The `EC_GROUP_get_curve_name` function. + #[must_use] + pub fn ec_group_get_curve_name(&self) -> c_int { + unsafe { EC_GROUP_get_curve_name(self.as_const()) } + } +} + +/// The `EC_curve_nid2nist` function. +#[must_use] +pub fn ec_curve_nid2nist(nid: c_int) -> Result<&'static CStr, BoringError> { + unsafe { Ok(CStr::from_ptr(EC_curve_nid2nist(nid)?.as_ptr())) } +} + +impl CHeapWrapper<EC_KEY> { + /// The `EC_KEY_generate_key` function. + #[must_use] + pub fn ec_key_generate_key(&mut self) -> Result<(), BoringError> { + unsafe { EC_KEY_generate_key(self.as_mut()) } + } + + /// The `EC_KEY_parse_private_key` function. + /// + /// If `group` is `None`, then the group pointer argument to + /// `EC_KEY_parse_private_key` will be NULL. + #[must_use] + pub fn ec_key_parse_private_key( + cbs: &mut CStackWrapper<CBS>, group: Option<CRef<'static, EC_GROUP>>, + ) -> Result<CHeapWrapper<EC_KEY>, BoringError> { + unsafe { + Ok(CHeapWrapper::new_from(EC_KEY_parse_private_key( + cbs.as_mut(), + group.map(|g| g.as_const()).unwrap_or(ptr::null()), + )?)) + } + } + + /// The `EC_KEY_get0_group` function. + #[must_use] + #[allow(clippy::needless_lifetimes)] // to be more explicit + pub fn ec_key_get0_group<'a>(&'a self) -> Result<CRef<'a, EC_GROUP>, BoringError> { + // get0 doesn't increment the refcount; the lifetimes ensure that the + // returned CRef can't outlive self + unsafe { Ok(CRef::new(EC_KEY_get0_group(self.as_const())?)) } + } + + /// The `EC_KEY_set_group` function. + #[must_use] + pub fn ec_key_set_group(&mut self, group: &CRef<'static, EC_GROUP>) -> Result<(), BoringError> { + unsafe { EC_KEY_set_group(self.as_mut(), group.as_const()) } + } + + /// The `EC_KEY_marshal_private_key` function. + #[must_use] + pub fn ec_key_marshal_private_key( + &self, cbb: &mut CStackWrapper<CBB>, + ) -> Result<(), BoringError> { + unsafe { EC_KEY_marshal_private_key(cbb.as_mut(), self.as_const(), 0) } + } +} + +/// The `ECDSA_sign` function. +/// +/// `ecdsa_sign` returns the number of bytes written to `sig`. +/// +/// # Panics +/// +/// `ecdsa_sign` panics if `sig` is shorter than the minimum required signature +/// size given by `ecdsa_size`, or if `key` doesn't have a group set. +#[must_use] +pub fn ecdsa_sign( + digest: &[u8], sig: &mut [u8], key: &CHeapWrapper<EC_KEY>, +) -> Result<usize, BoringError> { + unsafe { + // If we call ECDSA_sign with sig.len() < min_size, it will invoke UB. + // ECDSA_size fails if the key doesn't have a group set. + let min_size = ecdsa_size(key).unwrap_abort(); + assert_abort!(sig.len() >= min_size.get()); + + let mut sig_len: c_uint = 0; + ECDSA_sign( + 0, + digest.as_ptr(), + digest.len(), + sig.as_mut_ptr(), + &mut sig_len, + key.as_const(), + )?; + // ECDSA_sign guarantees that it only needs ECDSA_size bytes for the + // signature. + assert_abort!(sig_len as usize <= min_size.get()); + Ok(sig_len as usize) + } +} + +/// The `ECDSA_verify` function. +#[must_use] +pub fn ecdsa_verify(digest: &[u8], sig: &[u8], key: &CHeapWrapper<EC_KEY>) -> bool { + unsafe { + ECDSA_verify( + 0, + digest.as_ptr(), + digest.len(), + sig.as_ptr(), + sig.len(), + key.as_const(), + ) + } +} + +/// The `ECDSA_size` function. +#[must_use] +pub fn ecdsa_size(key: &CHeapWrapper<EC_KEY>) -> Result<NonZeroUsize, BoringError> { + unsafe { ECDSA_size(key.as_const()) } +} + +/// The `ED25519_keypair` function. +#[must_use] +pub fn ed25519_keypair() -> [u8; ED25519_PRIVATE_KEY_LEN as usize] { + let mut public_unused = [0u8; ED25519_PUBLIC_KEY_LEN as usize]; + let mut private = [0u8; ED25519_PRIVATE_KEY_LEN as usize]; + unsafe { + ED25519_keypair( + (&mut public_unused[..]).as_mut_ptr(), + (&mut private[..]).as_mut_ptr(), + ) + }; + private +} + +/// The `ED25519_sign` function. +#[must_use] +pub fn ed25519_sign(message: &[u8], private_key: &[u8; 64]) -> Result<[u8; 64], BoringError> { + let mut sig = [0u8; 64]; + unsafe { ED25519_sign(&mut sig, message.as_ptr(), message.len(), private_key)? }; + Ok(sig) +} + +/// The `ED25519_keypair_from_seed` function. +#[must_use] +pub fn ed25519_keypair_from_seed(seed: &[u8; 32]) -> ([u8; 32], [u8; 64]) { + let mut public = [0u8; 32]; + let mut private = [0u8; 64]; + unsafe { + ED25519_keypair_from_seed( + (&mut public[..]).as_mut_ptr(), + (&mut private[..]).as_mut_ptr(), + (&seed[..]).as_ptr(), + ) + }; + (public, private) +} + +/// The `ED25519_verify` function. +#[must_use] +pub fn ed25519_verify(message: &[u8], signature: &[u8; 64], public_key: &[u8; 32]) -> bool { + unsafe { ED25519_verify(message.as_ptr(), message.len(), signature, public_key) } +} + +impl CHeapWrapper<EVP_PKEY> { + /// The `EVP_parse_public_key` function. + #[must_use] + pub fn evp_parse_public_key( + cbs: &mut CStackWrapper<CBS>, + ) -> Result<CHeapWrapper<EVP_PKEY>, BoringError> { + unsafe { Ok(CHeapWrapper::new_from(EVP_parse_public_key(cbs.as_mut())?)) } + } + + /// The `EVP_marshal_public_key` function. + #[must_use] + pub fn evp_marshal_public_key(&self, cbb: &mut CStackWrapper<CBB>) -> Result<(), BoringError> { + unsafe { EVP_marshal_public_key(cbb.as_mut(), self.as_const()) } + } + + /// The `EVP_PKEY_assign_EC_KEY` function. + #[must_use] + pub fn evp_pkey_assign_ec_key(&mut self, ec_key: CHeapWrapper<EC_KEY>) { + unsafe { + // NOTE: It's very important that we use 'into_mut' here so that + // ec_key's refcount is not decremented. That's because + // EVP_PKEY_assign_EC_KEY doesn't increment the refcount of its + // argument. + let key = ec_key.into_mut(); + // EVP_PKEY_assign_EC_KEY only fails if key is NULL. + EVP_PKEY_assign_EC_KEY(self.as_mut(), key).unwrap_abort() + } + } + + /// The `EVP_PKEY_get1_EC_KEY` function. + #[must_use] + pub fn evp_pkey_get1_ec_key(&mut self) -> Result<CHeapWrapper<EC_KEY>, BoringError> { + // NOTE: It's important that we use get1 here, as it increments the + // refcount of the EC_KEY before returning a pointer to it. + unsafe { Ok(CHeapWrapper::new_from(EVP_PKEY_get1_EC_KEY(self.as_mut())?)) } + } +} + +/// The `EVP_PBE_scrypt` function. +#[allow(non_snake_case)] +#[must_use] +pub fn evp_pbe_scrypt( + password: &[u8], salt: &[u8], N: u64, r: u64, p: u64, max_mem: usize, out_key: &mut [u8], +) -> Result<(), BoringError> { + unsafe { + EVP_PBE_scrypt( + password.as_ptr() as *const c_char, + password.len(), + salt.as_ptr(), + salt.len(), + N, + r, + p, + max_mem, + out_key.as_mut_ptr(), + out_key.len(), + ) + } +} + +/// The `PKCS5_PBKDF2_HMAC` function. +#[cfg(feature = "kdf")] +#[must_use] +pub fn pkcs5_pbkdf2_hmac( + password: &[u8], salt: &[u8], iterations: c_uint, digest: &CRef<'static, EVP_MD>, + out_key: &mut [u8], +) -> Result<(), BoringError> { + unsafe { + raw::PKCS5_PBKDF2_HMAC( + password.as_ptr() as *const c_char, + password.len(), + salt.as_ptr(), + salt.len(), + iterations, + digest.as_const(), + out_key.len(), + out_key.as_mut_ptr(), + ) + } +} + +impl CStackWrapper<SHA512_CTX> { + /// Initializes a new `CStackWrapper<SHA512_CTX>` as a SHA-384 hash. + /// + /// The BoringSSL `SHA512_CTX` is used for both the SHA-512 and SHA-384 hash + /// functions. The implementation of `Default` for + /// `CStackWrapper<SHA512_CTX>` produces a context initialized for a SHA-512 + /// hash. In order to produce a context for a SHA-384 hash, use this + /// constructor instead. + #[must_use] + pub fn sha384_new() -> CStackWrapper<SHA512_CTX> { + unsafe { + let mut ctx = mem::uninitialized(); + SHA384_Init(&mut ctx); + CStackWrapper::new(ctx) + } + } +} + +macro_rules! impl_evp_digest { + (#[$doc:meta] $name:ident, $raw_name:ident) => { + #[$doc] + #[must_use] + pub fn $name() -> CRef<'static, EVP_MD> { + unsafe { CRef::new(::boringssl::raw::$raw_name()) } + } + }; +} + +impl CRef<'static, EVP_MD> { + impl_evp_digest!( + /// The `EVP_sha1` function. + evp_sha1, + EVP_sha1 + ); + impl_evp_digest!( + /// The `EVP_sha256` function. + evp_sha256, + EVP_sha256 + ); + impl_evp_digest!( + /// The `EVP_sha384` function. + evp_sha384, + EVP_sha384 + ); + impl_evp_digest!( + /// The `EVP_sha512` function. + evp_sha512, + EVP_sha512 + ); +} + +impl CStackWrapper<HMAC_CTX> { + /// Initializes a new `HMAC_CTX`. + /// + /// `hmac_ctx_new` initializes a new `HMAC_CTX` using `HMAC_CTX_init` and + /// then further initializes it with `HMAC_CTX_Init_ex`. It can only fail + /// due to OOM. + #[must_use] + pub fn hmac_ctx_new( + key: &[u8], md: &CRef<'static, EVP_MD>, + ) -> Result<CStackWrapper<HMAC_CTX>, BoringError> { + unsafe { + let mut ctx = mem::uninitialized(); + HMAC_CTX_init(&mut ctx); + HMAC_Init_ex( + &mut ctx, + key.as_ptr() as *const c_void, + key.len(), + md.as_const(), + )?; + Ok(CStackWrapper::new(ctx)) + } + } + + /// The `HMAC_Update` function. + #[must_use] + pub fn hmac_update(&mut self, data: &[u8]) { + unsafe { HMAC_Update(self.as_mut(), data.as_ptr(), data.len()) } + } + + // NOTE(joshlf): We require exactly the right length (as opposed to just + // long enough) so that we don't have to have hmac_final return a length. + + /// The `HMAC_Final` function. + /// + /// # Panics + /// + /// `hmac_final` panics if `out` is not exactly the right length (as defined + /// by `HMAC_size`). + #[must_use] + pub fn hmac_final(&mut self, out: &mut [u8]) { + unsafe { + let size = HMAC_size(self.as_const()); + assert_abort_eq!(out.len(), size); + let mut size = 0; + // HMAC_Final is documented to fail on allocation failure, but an + // internal comment states that it's infallible. In either case, we + // want to panic. Normally, for allocation failure, we'd put the + // unwrap higher in the stack, but since this is supposed to be + // infallible anyway, we put it here. + // + // TODO(joshlf): Remove this comment once HMAC_Final is documented + // as being infallible. + HMAC_Final(self.as_mut(), out.as_mut_ptr(), &mut size).unwrap_abort(); + // Guaranteed to be the value returned by HMAC_size. + assert_abort_eq!(out.len(), size as usize); + } + } +} + +/// Implements `CStackWrapper` for a hash context type. +/// +/// The caller provides doc comments, a public method name, and a private +/// function name (from the `raw` module) for an update function and a final +/// function (e.g., `SHA256_Update` and `SHA256_Final`). Note that, as multiple +/// impl blocks are allowed for a particular type, the same context type may be +/// used multiple times. This is useful because both SHA-384 and SHA-512 use the +/// `SHA512_CTX` context type. +macro_rules! impl_hash { + ($ctx:ident, $digest_len:ident, #[$update_doc:meta] $update:ident, $update_raw:ident, #[$final_doc:meta] $final:ident, $final_raw:ident) => { + impl CStackWrapper<$ctx> { + #[$update_doc] + pub fn $update(&mut self, data: &[u8]) { + unsafe { + ::boringssl::raw::$update_raw( + self.as_mut(), + data.as_ptr() as *const c_void, + data.len(), + ) + } + } + + #[$final_doc] + #[must_use] + pub fn $final( + &mut self, + ) -> [u8; ::boringssl::ffi::$digest_len as usize] { + unsafe { + let mut md: [u8; ::boringssl::ffi::$digest_len as usize] = mem::uninitialized(); + // SHA1_Final promises to return 1. SHA256_Final, + // SHA384_Final, and SHA512_Final all document that they + // only fail due to programmer error. The only input to the + // function which could cause this is the context. I suspect + // that the error condition is that XXX_Final is called + // twice without resetting, but I'm not sure. Until we + // figure it out, let's err on the side of caution and abort + // here. + // + // TODO(joshlf): Figure out how XXX_Final can fail. + ::boringssl::raw::$final_raw((&mut md[..]).as_mut_ptr(), self.as_mut()).unwrap_abort(); + md + } + } + } + }; + (@doc_string $s:expr) => (#[doc="The `"] #[doc=$s] #[doc="` function."]); +} + +impl_hash!( + SHA_CTX, + SHA_DIGEST_LENGTH, + /// The `SHA1_Update` function. + sha1_update, + SHA1_Update, + /// The `SHA1_Final` function. + sha1_final, + SHA1_Final +); +impl_hash!( + SHA256_CTX, + SHA256_DIGEST_LENGTH, + /// The `SHA256_Update` function. + sha256_update, + SHA256_Update, + /// The `SHA256_Final` function. + sha256_final, + SHA256_Final +); +impl_hash!( + SHA512_CTX, + SHA384_DIGEST_LENGTH, + /// The `SHA384_Update` function. + sha384_update, + SHA384_Update, + /// The `SHA384_Final` function. + sha384_final, + SHA384_Final +); +impl_hash!( + SHA512_CTX, + SHA512_DIGEST_LENGTH, + /// The `SHA512_Update` function. + sha512_update, + SHA512_Update, + /// The `SHA512_Final` function. + sha512_final, + SHA512_Final +); + +/// The `CRYPTO_memcmp` function. +/// +/// `crypto_memcmp` first verifies that `a.len() == b.len()` before calling +/// `CRYPTO_memcmp`. +#[must_use] +pub fn crypto_memcmp(a: &[u8], b: &[u8]) -> bool { + if a.len() != b.len() { + return false; + } + unsafe { + CRYPTO_memcmp( + a.as_ptr() as *const c_void, + b.as_ptr() as *const c_void, + a.len(), + ) == 0 + } +} + +/// The `RAND_bytes` function. +pub fn rand_bytes(buf: &mut [u8]) { + unsafe { RAND_bytes(buf.as_mut_ptr(), buf.len()) } +} + +/// An error generated by BoringSSL. +/// +/// The `Debug` impl prints a stack trace. Each element of the trace corresponds +/// to a function within BoringSSL which voluntarily pushed itself onto the +/// stack. In this sense, it is not the same as a normal stack trace. Each +/// element of the trace is of the form `[thread id]:error:[error code]:[library +/// name]:OPENSSL_internal:[reason string]:[file]:[line number]:[optional string +/// data]`. +/// +/// The `Display` impl prints the first element of the stack trace. +/// +/// Some BoringSSL functions do not record any error in the error stack. Errors +/// generated from such functions are printed as `error calling <function name>` +/// for both `Debug` and `Display` impls. +pub struct BoringError { + stack_trace: Vec<String>, +} + +impl BoringError { + /// Consumes the error stack. + /// + /// `f` is the name of the function that failed. If the error stack is empty + /// (some BoringSSL functions do not push errors onto the stack when + /// returning errors), the returned `BoringError` will simply note that the + /// named function failed; both the `Debug` and `Display` implementations + /// will return `error calling f`, where `f` is the value of the `f` + /// argument. + #[must_use] + fn consume_stack(f: &str) -> BoringError { + let stack_trace = { + let trace = get_error_stack_trace(); + if trace.is_empty() { + vec![format!("error calling {}", f)] + } else { + trace + } + }; + BoringError { stack_trace } + } + + /// The number of frames in the stack trace. + /// + /// Guaranteed to be at least 1. + #[must_use] + pub fn stack_depth(&self) -> usize { + self.stack_trace.len() + } +} + +fn get_error_stack_trace() -> Vec<String> { + // Credit to agl@google.com for this implementation. + + unsafe extern "C" fn error_callback(s: *const c_char, s_len: usize, ctx: *mut c_void) -> c_int { + let stack_trace = ctx as *mut Vec<String>; + let s = ::std::slice::from_raw_parts(s as *const u8, s_len - 1); + (*stack_trace).push(String::from_utf8_lossy(s).to_string()); + 1 + } + + let mut stack_trace = Vec::new(); + unsafe { + ERR_print_errors_cb( + Some(error_callback), + &mut stack_trace as *mut _ as *mut c_void, + ) + }; + stack_trace +} + +impl Display for BoringError { + fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> { + write!(f, "{}", self.stack_trace[0]) + } +} + +impl Debug for BoringError { + fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> { + for elem in &self.stack_trace { + writeln!(f, "{}", elem)?; + } + Ok(()) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use util::should_fail; + + #[test] + fn test_boring_error() { + CStackWrapper::cbs_with_temp_buffer(&[], |cbs| { + should_fail( + CHeapWrapper::evp_parse_public_key(cbs), + "boringssl::EVP_parse_public_key", + "public key routines:OPENSSL_internal:DECODE_ERROR", + ); + }); + } +}
diff --git a/src/boringssl/raw.rs b/src/boringssl/raw.rs new file mode 100644 index 0000000..76ea6db --- /dev/null +++ b/src/boringssl/raw.rs
@@ -0,0 +1,401 @@ +// Copyright 2018 Google LLC +// +// Use of this source code is governed by an MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT. + +//! Almost-raw bindings to the BoringSSL API. +//! +//! The `raw` module provides bindings to the BoringSSL API which add a little +//! bit of safety beyond the safety provided by completely raw bindings by +//! ensuring that all return values are checked for errors, and converting these +//! C-style return values into Rust `Result`s. +//! +//! This module also directly re-exports any raw bindings which are infallible +//! (e.g., `void` functions). + +// infallible functions +pub use boringssl::ffi::{CBB_cleanup, CBB_len, CBS_init, CBS_len, CRYPTO_memcmp, + EC_GROUP_get_curve_name, ED25519_keypair, ED25519_keypair_from_seed, + ERR_print_errors_cb, HMAC_CTX_init, HMAC_size}; + +use std::num::NonZeroUsize; +use std::os::raw::{c_char, c_int, c_uint, c_void}; +use std::ptr::{self, NonNull}; + +use boringssl::ffi::{self, CBB, CBS, EC_GROUP, EC_KEY, EVP_MD, EVP_PKEY, HMAC_CTX, SHA512_CTX}; + +use boringssl::wrapper::CInit; +use boringssl::BoringError; + +// bytestring.h + +impl_traits!(CBB, CDestruct => CBB_cleanup); +impl_traits!(CBS, CDestruct => _); + +#[allow(non_snake_case)] +#[must_use] +pub unsafe fn CBB_init(cbb: *mut CBB, initial_capacity: usize) -> Result<(), BoringError> { + one_or_err("CBB_init", ffi::CBB_init(cbb, initial_capacity)) +} + +#[allow(non_snake_case)] +#[must_use] +pub unsafe fn CBB_data(cbb: *const CBB) -> Result<NonNull<u8>, BoringError> { + ptr_or_err("CBB_init", ffi::CBB_data(cbb) as *mut _) +} + +// curve25519.h + +#[allow(non_snake_case)] +#[must_use] +pub unsafe fn ED25519_sign( + out: *mut [u8; 64], message: *const u8, message_len: usize, private_key: *const [u8; 64], +) -> Result<(), BoringError> { + one_or_err( + "ED25519_sign", + ffi::ED25519_sign( + out as *mut u8, + message, + message_len, + private_key as *const u8, + ), + ) +} + +#[allow(non_snake_case)] +#[must_use] +pub unsafe fn ED25519_verify( + message: *const u8, message_len: usize, signature: *const [u8; 64], public_key: *const [u8; 32], +) -> bool { + match ffi::ED25519_verify( + message, + message_len, + signature as *const u8, + public_key as *const u8, + ) { + 0 => false, + 1 => true, + // ED25519_verify promises to only return 0 or 1 + _ => unreachable_abort!(), + } +} + +// digest.h + +macro_rules! evp_digest { + ($name:ident) => { + #[allow(non_snake_case)] + #[must_use] + pub unsafe fn $name() -> NonNull<EVP_MD> { + // These return pointers to statically-allocated objects, so should + // never fail. + use boringssl::abort::UnwrapAbort; + ptr_or_err(stringify!($name), ffi::$name() as *mut _).unwrap_abort() + } + }; +} + +evp_digest!(EVP_sha1); +evp_digest!(EVP_sha256); +evp_digest!(EVP_sha384); +evp_digest!(EVP_sha512); + +// ec.h + +#[allow(non_snake_case)] +#[must_use] +pub unsafe fn EC_GROUP_new_by_curve_name(nid: c_int) -> Result<NonNull<EC_GROUP>, BoringError> { + ptr_or_err( + "EC_GROUP_new_by_curve_name", + ffi::EC_GROUP_new_by_curve_name(nid), + ) +} + +// ec_key.h + +impl_traits!(EC_KEY, CNew => EC_KEY_new, CUpRef => EC_KEY_up_ref, CFree => EC_KEY_free); +impl_traits!(EVP_PKEY, CNew => EVP_PKEY_new, CUpRef => EVP_PKEY_up_ref, CFree => EVP_PKEY_free); + +#[allow(non_snake_case)] +#[must_use] +pub unsafe fn EC_curve_nid2nist(nid: c_int) -> Result<NonNull<c_char>, BoringError> { + ptr_or_err("EC_curve_nid2nist", ffi::EC_curve_nid2nist(nid) as *mut _) +} + +#[allow(non_snake_case)] +#[must_use] +pub unsafe fn EC_KEY_generate_key(key: *mut EC_KEY) -> Result<(), BoringError> { + one_or_err("EC_KEY_generate_key", ffi::EC_KEY_generate_key(key)) +} + +#[allow(non_snake_case)] +#[must_use] +pub unsafe fn EC_KEY_get0_group(key: *const EC_KEY) -> Result<NonNull<EC_GROUP>, BoringError> { + ptr_or_err("EC_KEY_get0_group", ffi::EC_KEY_get0_group(key) as *mut _) +} + +#[allow(non_snake_case)] +#[must_use] +pub unsafe fn EC_KEY_marshal_private_key( + cbb: *mut CBB, key: *const EC_KEY, enc_flags: c_uint, +) -> Result<(), BoringError> { + one_or_err( + "EC_KEY_marshal_private_key", + ffi::EC_KEY_marshal_private_key(cbb, key, enc_flags), + ) +} + +#[allow(non_snake_case)] +#[must_use] +pub unsafe fn EC_KEY_parse_private_key( + cbs: *mut CBS, group: *const EC_GROUP, +) -> Result<NonNull<EC_KEY>, BoringError> { + ptr_or_err( + "EC_KEY_parse_private_key", + ffi::EC_KEY_parse_private_key(cbs, group), + ) +} + +#[allow(non_snake_case)] +#[must_use] +pub unsafe fn EC_KEY_set_group( + key: *mut EC_KEY, group: *const EC_GROUP, +) -> Result<(), BoringError> { + one_or_err("EC_KEY_set_group", ffi::EC_KEY_set_group(key, group)) +} + +// ecdsa.h + +#[allow(non_snake_case)] +#[must_use] +pub unsafe fn ECDSA_sign( + type_: c_int, digest: *const u8, digest_len: usize, sig: *mut u8, sig_len: *mut c_uint, + key: *const EC_KEY, +) -> Result<(), BoringError> { + one_or_err( + "ECDSA_sign", + ffi::ECDSA_sign(type_, digest, digest_len, sig, sig_len, key), + ) +} + +#[allow(non_snake_case)] +#[must_use] +pub unsafe fn ECDSA_size(key: *const EC_KEY) -> Result<NonZeroUsize, BoringError> { + NonZeroUsize::new(ffi::ECDSA_size(key)).ok_or_else(|| BoringError::consume_stack("ECDSA_size")) +} + +#[allow(non_snake_case)] +#[must_use] +pub unsafe fn ECDSA_verify( + type_: c_int, digest: *const u8, digest_len: usize, sig: *const u8, sig_len: usize, + key: *const EC_KEY, +) -> bool { + match ffi::ECDSA_verify(type_, digest, digest_len, sig, sig_len, key) { + 1 => true, + 0 => false, + // ECDSA_verify promises to only return 0 or 1 + _ => unreachable_abort!(), + } +} + +// evp.h + +#[allow(non_snake_case)] +#[must_use] +pub unsafe fn EVP_marshal_public_key( + cbb: *mut CBB, key: *const EVP_PKEY, +) -> Result<(), BoringError> { + one_or_err( + "EVP_marshal_public_key", + ffi::EVP_marshal_public_key(cbb, key), + ) +} + +#[allow(non_snake_case)] +#[must_use] +pub unsafe fn EVP_parse_public_key(cbs: *mut CBS) -> Result<NonNull<EVP_PKEY>, BoringError> { + ptr_or_err("EVP_parse_public_key", ffi::EVP_parse_public_key(cbs)) +} + +#[allow(non_snake_case)] +#[must_use] +pub unsafe fn EVP_PKEY_assign_EC_KEY( + pkey: *mut EVP_PKEY, key: *mut EC_KEY, +) -> Result<(), BoringError> { + one_or_err( + "EVP_PKEY_assign_EC_KEY", + ffi::EVP_PKEY_assign_EC_KEY(pkey, key), + ) +} + +#[allow(non_snake_case)] +#[must_use] +pub unsafe fn EVP_PKEY_get1_EC_KEY(pkey: *mut EVP_PKEY) -> Result<NonNull<EC_KEY>, BoringError> { + ptr_or_err("EVP_PKEY_get1_EC_KEY", ffi::EVP_PKEY_get1_EC_KEY(pkey)) +} + +#[allow(non_snake_case)] +#[allow(clippy::too_many_arguments)] +#[must_use] +pub unsafe fn EVP_PBE_scrypt( + password: *const c_char, password_len: usize, salt: *const u8, salt_len: usize, N: u64, r: u64, + p: u64, max_mem: usize, out_key: *mut u8, key_len: usize, +) -> Result<(), BoringError> { + one_or_err( + "EVP_PBE_scrypt", + ffi::EVP_PBE_scrypt( + password, + password_len, + salt, + salt_len, + N, + r, + p, + max_mem, + out_key, + key_len, + ), + ) +} + +#[cfg(feature = "kdf")] +#[allow(non_snake_case)] +#[allow(clippy::too_many_arguments)] +#[must_use] +pub unsafe fn PKCS5_PBKDF2_HMAC( + password: *const c_char, password_len: usize, salt: *const u8, salt_len: usize, + iterations: c_uint, digest: *const EVP_MD, key_len: usize, out_key: *mut u8, +) -> Result<(), BoringError> { + one_or_err( + "PKCS5_PBKDF2_HMAC", + ffi::PKCS5_PBKDF2_HMAC( + password, + password_len, + salt, + salt_len, + iterations, + digest, + key_len, + out_key, + ), + ) +} + +// hmac.h + +// NOTE: We don't implement CInit because some functions that take an HMAC_CTX +// pointer have extra invariants beyond simply having called HMAC_CTX_init. If +// we implemented CInit, then safe code would be able to construct a +// CStackWrapper<HMAC_CTX> using Default::default, and then pass a pointer to +// that object to functions that require extra initialization, leading to +// usoundness. +impl_traits!(HMAC_CTX, CDestruct => HMAC_CTX_cleanup); + +#[allow(non_snake_case)] +#[must_use] +pub unsafe fn HMAC_Init_ex( + ctx: *mut HMAC_CTX, key: *const c_void, key_len: usize, md: *const EVP_MD, +) -> Result<(), BoringError> { + one_or_err( + "HMAC_Init_ex", + ffi::HMAC_Init_ex(ctx, key, key_len, md, ptr::null_mut()), + ) +} + +#[allow(non_snake_case)] +#[must_use] +pub unsafe fn HMAC_Update(ctx: *mut HMAC_CTX, data: *const u8, data_len: usize) { + // HMAC_Update promises to return 1. + assert_abort_eq!(ffi::HMAC_Update(ctx, data, data_len), 1); +} + +#[allow(non_snake_case)] +#[must_use] +pub unsafe fn HMAC_Final( + ctx: *mut HMAC_CTX, out: *mut u8, out_len: *mut c_uint, +) -> Result<(), BoringError> { + one_or_err("HMAC_Final", ffi::HMAC_Final(ctx, out, out_len)) +} + +// rand.h + +#[allow(non_snake_case)] +#[must_use] +pub unsafe fn RAND_bytes(buf: *mut u8, len: usize) { + // RAND_bytes promises to return 1. + assert_abort_eq!(ffi::RAND_bytes(buf, len), 1); +} + +// sha.h + +#[allow(non_snake_case)] +#[must_use] +pub unsafe fn SHA384_Init(ctx: *mut SHA512_CTX) { + // SHA384_Init promises to return 1. + assert_abort_eq!(ffi::SHA384_Init(ctx), 1); +} + +// Implemented manually (rather than via impl_traits! or c_init!) so that we can +// assert_abort_eq! that the return value is 1. +unsafe impl CInit for ffi::SHA_CTX { + unsafe fn init(ctx: *mut Self) { + // SHA1_Init promises to return 1. + assert_abort_eq!(ffi::SHA1_Init(ctx), 1); + } +} +unsafe impl CInit for ffi::SHA256_CTX { + unsafe fn init(ctx: *mut Self) { + // SHA256_Init promises to return 1. + assert_abort_eq!(ffi::SHA256_Init(ctx), 1); + } +} +unsafe impl CInit for ffi::SHA512_CTX { + unsafe fn init(ctx: *mut Self) { + // SHA512_Init promises to return 1. + assert_abort_eq!(ffi::SHA512_Init(ctx), 1); + } +} + +// implement no-op destructors +impl_traits!(SHA_CTX, CDestruct => _); +impl_traits!(SHA256_CTX, CDestruct => _); +impl_traits!(SHA512_CTX, CDestruct => _); + +macro_rules! sha { + ($ctx:ident, $update:ident, $final:ident) => { + #[allow(non_snake_case)] + pub unsafe fn $update(ctx: *mut ffi::$ctx, data: *const c_void, len: usize) { + // All XXX_Update functions promise to return 1. + assert_abort_eq!(ffi::$update(ctx, data, len), 1); + } + #[allow(non_snake_case)] + pub unsafe fn $final(md: *mut u8, ctx: *mut ffi::$ctx) -> Result<(), BoringError> { + one_or_err(stringify!($final), ffi::$final(md, ctx)) + } + }; +} + +sha!(SHA_CTX, SHA1_Update, SHA1_Final); +sha!(SHA256_CTX, SHA256_Update, SHA256_Final); +sha!(SHA512_CTX, SHA384_Update, SHA384_Final); +sha!(SHA512_CTX, SHA512_Update, SHA512_Final); + +// utility functions + +// If code is 1, returns Ok, otherwise returns Err. f should be the name of the +// function that returned this value. +#[must_use] +pub fn one_or_err(f: &str, code: c_int) -> Result<(), BoringError> { + if code == 1 { + Ok(()) + } else { + Err(BoringError::consume_stack(f)) + } +} + +// If ptr is non-NULL, returns Ok, otherwise returns Err. f should be the name +// of the function that returned this value. +fn ptr_or_err<T>(f: &str, ptr: *mut T) -> Result<NonNull<T>, BoringError> { + NonNull::new(ptr).ok_or_else(|| BoringError::consume_stack(f)) +}
diff --git a/src/boringssl/wrapper.rs b/src/boringssl/wrapper.rs new file mode 100644 index 0000000..2c63130 --- /dev/null +++ b/src/boringssl/wrapper.rs
@@ -0,0 +1,370 @@ +// Copyright 2018 Google LLC +// +// Use of this source code is governed by an MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT. + +use std::marker::PhantomData; +use std::mem; +use std::ptr::NonNull; + +/// A trait that can be used to ensure that users of the boringssl module can't +/// implement a trait. +/// +/// See the [API Guidelines] for details. +/// +/// [API Guidelines]: https://rust-lang-nursery.github.io/api-guidelines/future-proofing.html#sealed-traits-protect-against-downstream-implementations-c-sealed +pub trait Sealed {} + +macro_rules! sealed { + ($name:ident) => { + impl ::boringssl::wrapper::Sealed for ::boringssl::raw::ffi::$name {} + }; +} + +macro_rules! impl_traits { + (@inner $name:ident, CNew => $fn:tt) => { + c_new!($name, $fn); + }; + (@inner $name:ident, CUpRef => $fn:tt) => { + c_up_ref!($name, $fn); + }; + (@inner $name:ident, CFree => $fn:tt) => { + c_free!($name, $fn); + }; + (@inner $name:ident, CInit => $fn:tt) => { + c_init!($name, $fn); + }; + (@inner $name:ident, CDestruct => $fn:tt) => { + c_destruct!($name, $fn); + }; + (@inner $name:ident, $trait:ident => $fn:tt) => { + compile_error!(concat!("unrecognized trait ", stringify!($trait))); + }; + ($name:ident, $($trait:ident => $fn:tt),*) => { + sealed!($name); + $(impl_traits!(@inner $name, $trait => $fn);)* + }; +} + +/// A C object from the BoringSSL API which can be allocated and constructed. +pub unsafe trait CNew: Sealed { + /// Returns a new, constructed, heap-allocated object, or NULL on failure. + /// + /// This should not be called directly; instead, use `new`. + #[deprecated = "do not call new_raw directly; instead, call new"] + unsafe fn new_raw() -> *mut Self; + + /// Returns a new, constructed, heap-allocated object, or `None` on failure. + #[must_use] + unsafe fn new() -> Option<NonNull<Self>> { + #[allow(deprecated)] + NonNull::new(Self::new_raw()) + } +} + +macro_rules! c_new { + ($name:ident, $new:ident) => { + unsafe impl ::boringssl::wrapper::CNew for ::boringssl::raw::ffi::$name { + unsafe fn new_raw() -> *mut Self { + ::boringssl::raw::ffi::$new() + } + } + }; +} + +/// A C object from the BoringSSL API which has a reference count that can be +/// increased. +pub unsafe trait CUpRef: Sealed { + /// Increases an object's reference count. + unsafe fn up_ref(slf: *mut Self); +} + +macro_rules! c_up_ref { + ($name:ident, $up_ref:ident) => { + unsafe impl ::boringssl::wrapper::CUpRef for ::boringssl::raw::ffi::$name { + unsafe fn up_ref(slf: *mut Self) { + use boringssl::abort::UnwrapAbort; + ::boringssl::raw::one_or_err( + stringify!($up_ref), + ::boringssl::raw::ffi::$up_ref(slf), + ).unwrap_abort() + } + } + }; +} + +/// A C object from the BoringSSL API which can be freed. +pub unsafe trait CFree: Sealed { + /// Frees a heap-allocated object. + /// + /// If this is a reference-counted object, `free` decrements the reference + /// count, and frees the object if it reaches zero. Otherwise, if this is + /// not a reference-counted object, it frees it. + unsafe fn free(slf: *mut Self); +} + +macro_rules! c_free { + ($name:ident, $free:ident) => { + unsafe impl ::boringssl::wrapper::CFree for ::boringssl::raw::ffi::$name { + unsafe fn free(slf: *mut Self) { + ::boringssl::raw::ffi::$free(slf) + } + } + }; +} + +/// A C object from the BoringSSL API which can be initialized. +pub unsafe trait CInit: Sealed { + /// Initializes an uninitialized object. + /// + /// # Safety + /// + /// `init` must not be called on an initialized object. + unsafe fn init(slf: *mut Self); +} + +#[allow(unused)] // TODO: Remove once it's used in the 'raw' module +macro_rules! c_init { + ($name:ident, $init:ident) => { + unsafe impl ::boringssl::wrapper::CInit for ::boringssl::raw::ffi::$name { + unsafe fn init(slf: *mut Self) { + ::boringssl::raw::ffi::$init(slf) + } + } + }; +} + +/// A C object from the BoringSSL API which can be destructed. +pub unsafe trait CDestruct: Sealed { + /// Destructs an initialized object. + /// + /// # Safety + /// + /// `slf` must be an initialized object. After a call to `destruct`, `slf` + /// is uninitialized. + unsafe fn destruct(slf: *mut Self); +} + +macro_rules! c_destruct { + ($name:ident, _) => { + unsafe impl ::boringssl::wrapper::CDestruct for ::boringssl::raw::ffi::$name { + unsafe fn destruct(_slf: *mut Self) {} + } + }; + ($name:ident, $destruct:tt) => { + unsafe impl ::boringssl::wrapper::CDestruct for ::boringssl::raw::ffi::$name { + unsafe fn destruct(slf: *mut Self) { + ::boringssl::raw::ffi::$destruct(slf) + } + } + }; +} + +/// A wrapper around a pointer to a heap-allocated, constructed C object from +/// the BoringSSL API. +/// +/// `CHeapWrapper` maintains the invariant that the object it references is +/// always allocated and constructed. This means that: +/// - If the object can be reference counted, `CHeapWrapper` implements `Clone` +/// by incrementing the reference count, and decrementing on `Drop`. +/// - If the object cannot be reference counted, `CHeapWrapper` does not +/// implement `Clone`, but will still free the object on `Drop`. +/// +/// `CHeapWrapper`s are not thread-safe; they do not implement `Send` or `Sync`. +pub struct CHeapWrapper<C: CFree> { + // NOTE: NonNull ensures that CHeapWrapper is !Send + !Sync. If this struct + // is changed, make sure it's still !Send + !Sync. + obj: NonNull<C>, +} + +impl<C: CFree> CHeapWrapper<C> { + /// Takes ownership of a constructed object. + /// + /// # Safety + /// + /// `obj` must point to an allocated, constructed object. The caller must + /// ensure that, when the returned `CHeapWrapper` is dropped, it is safe to + /// call `C::free` on `obj`. In most cases, this means that the caller + /// should not free `obj`, and instead consider ownership of `obj` to have + /// transferred to the new `CHeapWrapper`. + /// + /// The caller must also ensure that no pointers to the object will ever be + /// used by other threads so long as this `CHeapWrapper` exists. + #[must_use] + pub unsafe fn new_from(obj: NonNull<C>) -> CHeapWrapper<C> { + CHeapWrapper { obj } + } + + #[must_use] + pub fn as_mut(&mut self) -> *mut C { + self.obj.as_ptr() + } + + #[must_use] + pub fn as_const(&self) -> *const C { + self.obj.as_ptr() + } + + /// Consumes this `CHeapWrapper` and return the underlying pointer. + /// + /// The object will not be freed. Instead, the caller takes logical + /// ownership of the object. + #[must_use] + pub fn into_mut(self) -> *mut C { + // NOTE: This method safe for the same reason that mem::forget is safe: + // it's equivalent to sending it to a thread that goes to sleep forever + // or creating a Rc cycle or some other silly-but-safe behavior. + let ptr = self.obj.as_ptr(); + mem::forget(self); + ptr + } +} + +impl<C: CNew + CFree> Default for CHeapWrapper<C> { + fn default() -> CHeapWrapper<C> { + // TODO(joshlf): In order for this to be safe, CNew must provide the + // safety guarantee that it's always safe to call CNew::new and then + // later to call CFree::free on that object (e.g., see the safety + // comment on CStackWrapper::new). + unsafe { + use boringssl::abort::UnwrapAbort; + let obj = C::new().expect_abort("could not allocate object"); + CHeapWrapper { obj } + } + } +} + +impl<C: CUpRef + CFree> Clone for CHeapWrapper<C> { + fn clone(&self) -> CHeapWrapper<C> { + unsafe { C::up_ref(self.obj.as_ptr()) }; + CHeapWrapper { obj: self.obj } + } +} + +impl<C: CFree> Drop for CHeapWrapper<C> { + fn drop(&mut self) { + unsafe { C::free(self.obj.as_ptr()) }; + } +} + +/// A wrapper around a pointer to a C object from the BoringSSL API. +/// +/// Unlike `CHeapWrapper` or `CStackWrapper`, `CRef` does not own the pointed-to +/// object, but merely borrows it like a normal Rust reference. The only reason +/// to use `CRef<C>` instead of a `&C` is to make it so that access to the `C` +/// is unsafe, as `CRef` only exposes a raw pointer accessor for its object. +/// +/// `CRef` maintains the invariant that the object it references is always +/// allocated and constructed, and that mutable access to the object is disabled +/// for the lifetime of the `CRef`. +pub struct CRef<'a, C> { + // NOTE: NonNull ensures that CHeapWrapper is !Send + !Sync. If this struct + // is changed, make sure it's still !Send + !Sync. + obj: NonNull<C>, + // Make sure CRef has the lifetime 'a. + _lifetime: PhantomData<&'a ()>, +} + +impl<'a, C> CRef<'a, C> { + /// Creates a new `CRef` from a raw pointer. + /// + /// # Safety + /// + /// `obj` must point to an allocated, constructed object. The caller must + /// ensure that, for the lifetime, `'a`, `obj` will continue to point to the + /// same allocated, constructed object, and that mutable access to the + /// object will be disallowed. + /// + /// The caller must also ensure that no other pointers to the object will + /// ever be sent to other threads so long as this `CRef` exists. + #[must_use] + pub unsafe fn new(obj: NonNull<C>) -> CRef<'a, C> { + CRef { + obj, + _lifetime: PhantomData, + } + } + + #[must_use] + pub fn as_const(&self) -> *const C { + self.obj.as_ptr() + } +} + +/// A wrapper around a constructed C object from the BoringSSL API. +/// +/// `CStackWrapper` maintains the invariant that the object it contains is +/// always constructed. The object is destructed on `Drop`. +/// +/// `CStackWrapper`s are not thread-safe; they do not implement `Send` or +/// `Sync`. +pub struct CStackWrapper<C: CDestruct> { + obj: C, + // Make sure CStackWrapper doesn't implement Send or Sync regardless of C. + _no_sync: PhantomData<*mut ()>, +} + +impl<C: CDestruct> CStackWrapper<C> { + /// Constructs a new `CStackWrapper`. + /// + /// # Safety + /// + /// `obj` must be constructed, and it must be safe for `C::destruct` to be + /// called on `obj` when this `CStackWrapper` is dropped. + #[must_use] + pub unsafe fn new(obj: C) -> CStackWrapper<C> { + CStackWrapper { + obj, + _no_sync: PhantomData, + } + } + + #[must_use] + pub fn as_mut(&mut self) -> *mut C { + &mut self.obj + } + + #[must_use] + pub fn as_const(&self) -> *const C { + &self.obj + } +} + +impl<C: CInit + CDestruct> Default for CStackWrapper<C> { + // TODO(joshlf): In order for this to be safe, CInit must provide the safety + // guarantee that it's always safe to call CInit::init and then later to + // call CDestruct::destruct on that object (e.g., see the safety comment on + // CStackWrapper::new). + fn default() -> CStackWrapper<C> { + unsafe { + let mut obj: C = mem::uninitialized(); + C::init(&mut obj); + CStackWrapper { + obj, + _no_sync: PhantomData, + } + } + } +} + +impl<C: CDestruct> Drop for CStackWrapper<C> { + fn drop(&mut self) { + unsafe { C::destruct(&mut self.obj) } + } +} + +#[cfg(test)] +mod tests { + use super::*; + use boringssl::EC_KEY; + + #[test] + fn test_heap_wrapper_into_mut() { + // Test that CHeapWrapper::into_mut doesn't free the pointer. If it + // does, then EC_KEY::free is likely (though not guaranteed) to abort + // when it finds the refcount at 0. + let key = CHeapWrapper::<EC_KEY>::default(); + unsafe { EC_KEY::free(key.into_mut()) }; + } +}
diff --git a/src/hash.rs b/src/hash.rs new file mode 100644 index 0000000..39ecef6 --- /dev/null +++ b/src/hash.rs
@@ -0,0 +1,4389 @@ +// Copyright 2018 Google LLC +// +// Use of this source code is governed by an MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT. + +//! Cryptographic hash functions. + +use std::fmt::{self, Debug, Display, Formatter}; + +use boringssl::{self, CStackWrapper}; + +pub(crate) mod inner { + use boringssl::{CRef, EVP_MD}; + + pub trait Hasher { + fn evp_md() -> CRef<'static, EVP_MD>; + } + + pub trait Digest { + /// Returns a digest of all zeroes. + /// + /// This is not exposed to the user since the all-zeroes digest is only + /// useful in implementing this crate (namely, being able to create a + /// digest to use as an out buffer), and isn't actually a meaningful + /// digest in the sense of being the output of a hash function. + fn zero() -> Self; + + /// Returns a reference to the bytes of the digest. + /// + /// We do this instead of AsRef<[u8]> because the latter would expose + /// the as_ref method to the user. + /// + /// NOTE: This method is only used by signature implementations, and + /// should be removed once const generics enable the Digest::bytes + /// method to return `[u8; Self::DIGEST_LEN]` rather than an opaque + /// associated type. + fn as_ref(&self) -> &[u8]; + + /// Returns a mutable reference to the bytes of the digest. + /// + /// We do this instead of AsMut<[u8]> because the latter would expose + /// the as_mut method to the user. + fn as_mut(&mut self) -> &mut [u8]; + } +} + +/// A cryptographic hash function. +#[must_use] +pub trait Hasher: Default + self::inner::Hasher { + /// The output digest. + #[must_use] + type Digest: Digest; + + /// Adds bytes to the hash. + fn update(&mut self, bytes: &[u8]); + + /// Returns the digest of the bytes added so far. + #[must_use] + fn finish(self) -> Self::Digest; + + /// Computes the hash of a sequence of bytes. + /// + /// `hash` creates a new instance of this hash function, adds `bytes` to it, + /// and then computes the digest. + #[must_use] + fn hash(bytes: &[u8]) -> Self::Digest { + let mut h = Self::default(); + h.update(bytes); + h.finish() + } +} + +/// The output of a `Hash`. +#[must_use] +pub trait Digest: Eq + PartialEq + Display + Debug + Sized + self::inner::Digest { + /// The length in bytes of this digest. + const DIGEST_LEN: usize; + + /// The byte array equivalent of this digest. + /// + /// `Bytes` is guaranteed to be `[u8; DIGEST_LEN]`. Once const generics are + /// supported, this type will be removed and replaced with `[u8; + /// DIGEST_LEN]`. + type Bytes; + + /// Constructs a new digest from bytes. + #[must_use] + fn from_bytes(bytes: Self::Bytes) -> Self; + + /// Returns the bytes of this digest. + #[must_use] + fn bytes(&self) -> Self::Bytes; +} + +// NOTE: InsecureSha1 is not publicly available; it is only used in HMAC-SHA1. +#[cfg(feature = "insecure")] +#[deprecated(note = "SHA-1 is considered insecure")] +#[derive(Default)] +pub(crate) struct InsecureSha1 { + ctx: CStackWrapper<boringssl::SHA_CTX>, +} + +#[cfg(feature = "insecure")] +pub(crate) mod insecure_sha1_digest { + use boringssl; + + /// INSECURE: The digest output by the SHA-1 hash function. + /// + /// # Security + /// + /// SHA-1 is considered insecure, and should only be used for compatibility + /// with legacy applications. + #[deprecated(note = "SHA-1 is considered insecure")] + pub struct InsecureSha1Digest(pub(crate) [u8; boringssl::SHA_DIGEST_LENGTH as usize]); +} + +/// The SHA-256 hash function. +#[derive(Default)] +#[must_use] +pub struct Sha256 { + ctx: CStackWrapper<boringssl::SHA256_CTX>, +} + +impl_debug!(Sha256, "Sha256"); + +/// The digest output by the SHA-256 hash function. +#[must_use] +pub struct Sha256Digest(pub(crate) [u8; boringssl::SHA256_DIGEST_LENGTH as usize]); + +/// The SHA-384 hash function. +#[must_use] +pub struct Sha384 { + ctx: CStackWrapper<boringssl::SHA512_CTX>, +} + +impl_debug!(Sha384, "Sha384"); + +impl Default for Sha384 { + fn default() -> Sha384 { + // The Default impl for CStackWrapper<boringssl::SHA512_CTX> initializes + // it for a SHA-512 hash. Thus, we have to implement Default manually + // instead of deriving Default on Sha384. + Sha384 { + ctx: CStackWrapper::sha384_new(), + } + } +} + +/// The digest output by the SHA-384 hash function. +#[must_use] +pub struct Sha384Digest(pub(crate) [u8; boringssl::SHA384_DIGEST_LENGTH as usize]); + +/// The SHA-512 hash function. +#[derive(Default)] +#[must_use] +pub struct Sha512 { + ctx: CStackWrapper<boringssl::SHA512_CTX>, +} + +impl_debug!(Sha512, "Sha512"); + +/// The digest output by the SHA-512 hash function. +#[must_use] +pub struct Sha512Digest(pub(crate) [u8; boringssl::SHA512_DIGEST_LENGTH as usize]); + +/// Implements the `Hash` and `Digest` traits. +/// +/// The caller provides the name of the hash type and the name and byte length +/// of the digest type. The caller also provides the names of methods on the +/// hash type's `ctx` field to update and finalize the hash. These correspond +/// to, e.g., the BoringSSL `SHA256_Update` and `SHA256_Final` functions. +/// Finally, the caller provides the name of the `CRef` constructor to construct +/// a `CRef<'static, EVP_MD>` for this hash type. +/// +/// For the digest type, the traits `PartialEq`, `Eq`, `Display`, and `Debug` +/// are also implemented. +macro_rules! impl_hash { + ($name:ident, $digest_name:path, $digest_len:path, $update:ident, $final:ident, $evp_md:ident) => { + #[allow(deprecated)] + impl ::util::Sealed for $name {} + #[allow(deprecated)] + impl Hasher for $name { + type Digest = $digest_name; + fn update(&mut self, bytes: &[u8]) { + #[allow(deprecated)] + self.ctx.$update(bytes); + } + fn finish(mut self) -> Self::Digest { + #[allow(deprecated)] + $digest_name(self.ctx.$final()) + } + } + #[allow(deprecated)] + impl self::inner::Hasher for $name { + fn evp_md() -> ::boringssl::CRef<'static, ::boringssl::EVP_MD> { + ::boringssl::CRef::$evp_md() + } + } + #[allow(deprecated)] + impl self::inner::Digest for $digest_name { + fn zero() -> Self { + $digest_name([0; $digest_len as usize]) + } + fn as_ref(&self) -> &[u8] { + &self.0[..] + } + fn as_mut(&mut self) -> &mut [u8] { + &mut self.0[..] + } + } + #[allow(deprecated)] + impl Digest for $digest_name { + const DIGEST_LEN: usize = $digest_len as usize; + type Bytes = [u8; $digest_len as usize]; + + fn from_bytes(bytes: Self::Bytes) -> Self { + $digest_name(bytes) + } + fn bytes(&self) -> Self::Bytes { + self.0 + } + } + #[allow(deprecated)] + impl PartialEq for $digest_name { + fn eq(&self, other: &Self) -> bool { + boringssl::crypto_memcmp(&self.0, &other.0) + } + } + #[allow(deprecated)] + impl Eq for $digest_name {} + #[allow(deprecated)] + impl Display for $digest_name { + fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> { + for byte in &self.0[..] { + write!(f, "{:x}", byte)?; + } + Ok(()) + } + } + #[allow(deprecated)] + impl Debug for $digest_name { + fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> { + Display::fmt(self, f) + } + } + }; +} + +#[cfg(feature = "insecure")] +impl_hash!( + InsecureSha1, + self::insecure_sha1_digest::InsecureSha1Digest, + boringssl::SHA_DIGEST_LENGTH, + sha1_update, + sha1_final, + evp_sha1 +); +impl_hash!( + Sha256, + Sha256Digest, + boringssl::SHA256_DIGEST_LENGTH, + sha256_update, + sha256_final, + evp_sha256 +); +impl_hash!( + Sha384, + Sha384Digest, + boringssl::SHA384_DIGEST_LENGTH, + sha384_update, + sha384_final, + evp_sha384 +); +impl_hash!( + Sha512, + Sha512Digest, + boringssl::SHA512_DIGEST_LENGTH, + sha512_update, + sha512_final, + evp_sha512 +); + +#[cfg(test)] +mod tests { + #[cfg(feature = "insecure")] + use super::insecure_sha1_digest::*; + use super::*; + + #[test] + fn test_constants() { + assert_eq!(<Sha256 as Hasher>::Digest::DIGEST_LEN, 32); + assert_eq!(<Sha384 as Hasher>::Digest::DIGEST_LEN, 48); + assert_eq!(<Sha512 as Hasher>::Digest::DIGEST_LEN, 64); + + assert_eq!(<Sha256 as Hasher>::Digest::DIGEST_LEN, 32); + assert_eq!(<Sha384 as Hasher>::Digest::DIGEST_LEN, 48); + assert_eq!(<Sha512 as Hasher>::Digest::DIGEST_LEN, 64); + + #[cfg(feature = "insecure")] + { + #[allow(deprecated)] + let len = <InsecureSha1 as Hasher>::Digest::DIGEST_LEN; + assert_eq!(len, 20); + + #[allow(deprecated)] + let len = InsecureSha1Digest::DIGEST_LEN; + assert_eq!(len, 20); + } + } + + #[test] + fn test_hash() { + struct TestCase { + input: &'static [u8], + #[cfg(feature = "insecure")] + #[allow(deprecated)] + sha1: <InsecureSha1 as Hasher>::Digest, + sha256: <Sha256 as Hasher>::Digest, + sha384: <Sha384 as Hasher>::Digest, + sha512: <Sha512 as Hasher>::Digest, + } + + for case in TEST_CASES.iter() { + fn test<H: Hasher>(input: &'static [u8], digest: &H::Digest) { + let got = H::hash(input); + assert_eq!(&got, digest, "input: {:?}", input); + // Also use this as an opportunity to test Digest::from_bytes + // and Digest::as_ref. + assert_eq!( + H::Digest::from_bytes(got.bytes()), + H::Digest::from_bytes(digest.bytes()), + "input: {:?}", + input + ); + // Test that adding bytes incrementally works too. + let mut hash = H::default(); + for b in input { + hash.update(&[*b]); + } + assert_eq!(&hash.finish(), digest, "input: {:?}", input); + } + #[cfg(feature = "insecure")] + #[allow(deprecated)] + test::<InsecureSha1>(case.input, &case.sha1); + test::<Sha256>(case.input, &case.sha256); + test::<Sha384>(case.input, &case.sha384); + test::<Sha512>(case.input, &case.sha512); + } + + macro_rules! test_case { + ($input:expr, $sha1:expr, $sha256:expr, $sha384:expr, $sha512:expr) => { + #[allow(deprecated)] + TestCase { + input: &$input, + #[cfg(feature = "insecure")] + sha1: InsecureSha1Digest($sha1), + sha256: Sha256Digest($sha256), + sha384: Sha384Digest($sha384), + sha512: Sha512Digest($sha512), + } + }; + } + + // These test cases were generated using the following script. Each is a + // randomly-generated input, with each length between 1 and 128 bytes + // represented. + // + // # Generate 10000 bytes/20000 hex characters of random data + // function rand { dd if=/dev/urandom bs=1 count=10000 | hexdump -ve '1/1 "%.2x"'; } + // + // # Convert hex to raw bytes + // function hex_to_bytes { perl -pe 's/([0-9a-f]{2})/chr hex $1/gie'; } + // + // # Convert hex to a Rust array + // function hex_to_array { echo -n "["; while read -n 2 c; do echo -n "0x${c},"; + // done; echo "]"; } + // + // # Usage: hash <input-hex> <hash> + // function hash { echo -n $(echo -n "$1" | hex_to_bytes | openssl dgst "-${2}" \ + // | cut -d ' ' -f 1) | hex_to_array; } + // + // # Only even numbers of hex characters + // for i in `seq 2 2 256`; do + // INPUT=$(rand 2>/dev/null | head -c $i); + // echo 'test_case!'"($(echo -n ${INPUT} | hex_to_array), \ + // $(hash ${INPUT} sha256), $(hash ${INPUT} sha384), $(hash ${INPUT} sha512)),"; + // done + const TEST_CASES: &[TestCase] = &[ + test_case!( + [0x81,], + [ + 0xa3, 0xf2, 0x94, 0x23, 0x5f, 0xe5, 0x42, 0x20, 0x05, 0xae, 0x9b, 0xc3, 0xa0, + 0xd1, 0xbf, 0xfe, 0x12, 0xcf, 0xe3, 0x53, + ], + [ + 0x59, 0x1b, 0x7c, 0xc9, 0x50, 0x37, 0x82, 0x2d, 0xec, 0x5a, 0x4d, 0x59, 0x3a, + 0x2e, 0x2e, 0x8b, 0x19, 0xc0, 0x7d, 0xdd, 0x25, 0x70, 0xe5, 0x69, 0x90, 0x03, + 0xd1, 0x7f, 0x14, 0xc4, 0x40, 0xa6, + ], + [ + 0x1f, 0xe1, 0x9e, 0x83, 0xb5, 0x18, 0xc0, 0x34, 0x22, 0x46, 0x83, 0xc9, 0x6c, + 0x86, 0x90, 0x8e, 0x49, 0x1c, 0x09, 0x12, 0xdb, 0xfb, 0x2f, 0xb5, 0x10, 0xa2, + 0xa3, 0x56, 0xd8, 0xf7, 0xc0, 0x20, 0x0e, 0x16, 0x42, 0xcd, 0x74, 0x61, 0x28, + 0x1d, 0x9b, 0xa0, 0x6f, 0x6c, 0x70, 0x18, 0x0a, 0xd6, + ], + [ + 0xc8, 0x41, 0x85, 0xc9, 0xa7, 0x89, 0x2e, 0x69, 0x44, 0x20, 0x9f, 0x89, 0xdb, + 0x2e, 0xec, 0xf4, 0x5d, 0x62, 0x2c, 0xf4, 0xcf, 0xff, 0x0c, 0xae, 0xb9, 0x2e, + 0x79, 0x51, 0xe3, 0x42, 0x54, 0x95, 0xb5, 0x07, 0xd1, 0x0b, 0xec, 0x92, 0x7e, + 0xce, 0x25, 0x31, 0xf2, 0x09, 0x58, 0x8f, 0xc6, 0xfa, 0x37, 0x51, 0x9f, 0xcd, + 0x82, 0xfa, 0xd4, 0x91, 0x66, 0xfe, 0x46, 0x89, 0x8a, 0x77, 0x73, 0x12, + ] + ), + test_case!( + [0xb0, 0x04,], + [ + 0x6c, 0x1a, 0x3e, 0x76, 0xc0, 0xf3, 0x02, 0x1e, 0x96, 0xa8, 0x23, 0x6f, 0xae, + 0x9f, 0x61, 0x1d, 0xaa, 0x6a, 0xb9, 0x4f, + ], + [ + 0xe8, 0xd9, 0x86, 0xb6, 0x05, 0x45, 0x24, 0xfc, 0x92, 0xe3, 0xac, 0xd6, 0x82, + 0x13, 0x76, 0x42, 0xdb, 0x72, 0x63, 0x07, 0x7f, 0xe5, 0xbd, 0x9d, 0x03, 0xa3, + 0xc2, 0xd1, 0x02, 0xd9, 0x4e, 0x47, + ], + [ + 0xb7, 0xc9, 0xcf, 0x0e, 0xa1, 0xd7, 0x10, 0x1a, 0x23, 0xf2, 0x30, 0x9f, 0x35, + 0x89, 0xfd, 0x96, 0x48, 0x3c, 0xdf, 0x3f, 0x92, 0x84, 0x25, 0xbe, 0xf3, 0xb6, + 0xdf, 0xdd, 0xa9, 0x53, 0x04, 0xe2, 0x1b, 0x94, 0x05, 0xe7, 0xc2, 0xa4, 0xde, + 0x77, 0x0c, 0xea, 0xb2, 0xd1, 0x34, 0x6d, 0x24, 0x7b, + ], + [ + 0xeb, 0xe3, 0xe7, 0x18, 0xe7, 0xef, 0xfc, 0xa8, 0x76, 0x4c, 0xd0, 0x6d, 0x64, + 0x52, 0xd1, 0x57, 0x6a, 0x2e, 0x2b, 0xcc, 0xc8, 0x53, 0xe2, 0x62, 0x91, 0xfa, + 0x8a, 0x8a, 0x9a, 0xf0, 0x7e, 0x3b, 0x56, 0xa1, 0xf9, 0x6e, 0x51, 0xe5, 0x4b, + 0x52, 0xc2, 0xfe, 0x48, 0xb8, 0x3d, 0xa7, 0xb9, 0x11, 0xd7, 0x96, 0xa0, 0xa6, + 0xf7, 0x61, 0xb3, 0xd9, 0x21, 0x78, 0x48, 0x7f, 0x21, 0x0a, 0xfe, 0x7a, + ] + ), + test_case!( + [0xdd, 0x6f, 0x24,], + [ + 0x1b, 0xb4, 0x6d, 0x86, 0xef, 0xb7, 0xc8, 0x0f, 0x38, 0xd1, 0x9b, 0x36, 0xc1, + 0xe2, 0x22, 0xa6, 0xee, 0x97, 0x4d, 0x14, + ], + [ + 0x69, 0xe1, 0x07, 0x53, 0x8a, 0xb7, 0x44, 0x1c, 0xd0, 0xeb, 0x6a, 0x1f, 0x4f, + 0x55, 0xe7, 0x1b, 0xdc, 0x6b, 0x1f, 0xe0, 0xa5, 0xae, 0x16, 0x89, 0x83, 0x29, + 0xdc, 0x86, 0x51, 0x1f, 0x03, 0x60, + ], + [ + 0xe6, 0x08, 0xf5, 0x30, 0x24, 0x0d, 0x9c, 0xd6, 0x0b, 0x91, 0x58, 0x22, 0x01, + 0x88, 0x6c, 0x50, 0x15, 0xef, 0x6f, 0xbc, 0x62, 0x6c, 0x2a, 0xfa, 0xa0, 0x1d, + 0xc2, 0xa5, 0xf6, 0x57, 0x9f, 0x35, 0x61, 0x02, 0xa8, 0x2c, 0x07, 0x11, 0x21, + 0xf2, 0x10, 0xf9, 0x37, 0x04, 0xdf, 0xe4, 0xa5, 0xa9, + ], + [ + 0x08, 0x1a, 0x0f, 0xda, 0xae, 0x84, 0xd5, 0xe1, 0x39, 0xa8, 0xa7, 0xd7, 0x1f, + 0xd3, 0xe9, 0x2a, 0x7e, 0x47, 0xd1, 0x5f, 0xe7, 0xf3, 0x16, 0xdc, 0x1b, 0x21, + 0x1b, 0xeb, 0xbd, 0xec, 0xbb, 0xf2, 0x3a, 0xfb, 0xda, 0x51, 0x7c, 0xdb, 0x95, + 0x87, 0x32, 0xdb, 0x44, 0xfd, 0xce, 0xe9, 0x25, 0xee, 0x85, 0x48, 0x3c, 0x1d, + 0x95, 0x60, 0x88, 0xcb, 0x45, 0x30, 0xa9, 0x0e, 0x6b, 0xea, 0x23, 0x6d, + ] + ), + test_case!( + [0x5a, 0x37, 0x17, 0x5b,], + [ + 0x06, 0xf9, 0x8e, 0x7e, 0xc1, 0xc6, 0x31, 0x29, 0xef, 0x02, 0x17, 0x93, 0x70, + 0x34, 0x3e, 0x8f, 0x17, 0xca, 0xa7, 0x2c, + ], + [ + 0xe6, 0x91, 0x73, 0xa1, 0xc0, 0xbb, 0xce, 0xc0, 0x7d, 0xef, 0x7e, 0x20, 0x48, + 0x02, 0xf9, 0x96, 0x8f, 0x0b, 0xc6, 0x47, 0x1a, 0x17, 0x84, 0x50, 0x4d, 0xd3, + 0xf7, 0x85, 0xe7, 0x4e, 0x83, 0xa7, + ], + [ + 0x1a, 0x1b, 0x23, 0x3f, 0x2f, 0x38, 0x91, 0x35, 0x28, 0xfa, 0x8a, 0x64, 0xf6, + 0xf7, 0x36, 0x47, 0xf9, 0x84, 0x67, 0x80, 0x83, 0xe8, 0xbd, 0x2b, 0xcd, 0x8d, + 0x5f, 0x0b, 0x29, 0xb2, 0x60, 0xba, 0x88, 0x84, 0x54, 0x9a, 0x67, 0xcb, 0x74, + 0x02, 0x75, 0xe8, 0xb2, 0xd7, 0xd7, 0x27, 0xa3, 0x72, + ], + [ + 0x7f, 0xbc, 0x99, 0xa2, 0xce, 0x12, 0x99, 0x22, 0xf1, 0x8a, 0x46, 0x0f, 0xd8, + 0xf4, 0x08, 0x3a, 0xd2, 0xd8, 0x0f, 0x59, 0x99, 0x3f, 0x5a, 0x21, 0xa7, 0xdf, + 0xa4, 0x49, 0x94, 0xcf, 0x75, 0x25, 0x4f, 0xc4, 0x6f, 0x57, 0x6a, 0x60, 0xf8, + 0x34, 0x2b, 0xdc, 0x17, 0x2b, 0xed, 0xe7, 0x84, 0x5e, 0xa1, 0xb8, 0x5b, 0x49, + 0x84, 0xa7, 0x58, 0x03, 0x6e, 0x8e, 0x6b, 0x3b, 0x6d, 0x2f, 0x9d, 0x83, + ] + ), + test_case!( + [0x81, 0x30, 0x79, 0xfd, 0xb7,], + [ + 0x56, 0x13, 0xb1, 0x9d, 0x6e, 0x17, 0x88, 0xb7, 0x88, 0xe8, 0xd2, 0x96, 0x3c, + 0x94, 0x2e, 0xc8, 0xbe, 0xd5, 0xec, 0x23, + ], + [ + 0xb1, 0xd3, 0x71, 0xc8, 0x54, 0x7d, 0x15, 0x4c, 0x0a, 0x73, 0x4f, 0x62, 0x85, + 0xa7, 0x2d, 0x20, 0x98, 0xcd, 0xbc, 0x83, 0x0d, 0x54, 0x90, 0xef, 0x72, 0xd2, + 0x9f, 0xa2, 0x7f, 0x98, 0x85, 0x93, + ], + [ + 0xba, 0xcc, 0x19, 0x8d, 0x5d, 0x03, 0xcb, 0x8e, 0xcb, 0x0b, 0xfb, 0x48, 0x2e, + 0x4b, 0xa0, 0x40, 0xef, 0xd5, 0x4a, 0xfc, 0x90, 0xdb, 0x9d, 0xae, 0x88, 0x08, + 0x7e, 0x94, 0x04, 0x58, 0x15, 0x74, 0x82, 0x49, 0xbf, 0xee, 0x1f, 0x9a, 0x96, + 0xa9, 0x73, 0xb5, 0x21, 0x18, 0xaf, 0x51, 0x8e, 0x5d, + ], + [ + 0xba, 0x90, 0x06, 0xe0, 0xc3, 0xc6, 0xd3, 0x94, 0xc5, 0x3d, 0x20, 0x14, 0x91, + 0xb3, 0x06, 0x97, 0xfa, 0xe9, 0x5f, 0x99, 0x11, 0x72, 0x79, 0xf1, 0x74, 0x0e, + 0xe1, 0x06, 0x6b, 0x60, 0xaa, 0x3f, 0x9c, 0xc7, 0x10, 0xae, 0xf0, 0x05, 0x28, + 0xdb, 0x26, 0x60, 0xa9, 0x00, 0xfb, 0xcb, 0x5f, 0x34, 0xbf, 0xd6, 0x4b, 0x15, + 0x5f, 0x6a, 0xad, 0xa3, 0xbc, 0x9a, 0x76, 0x8e, 0xef, 0x46, 0x36, 0xd8, + ] + ), + test_case!( + [0x70, 0xe4, 0x89, 0xe4, 0x36, 0xf9,], + [ + 0xaf, 0x8f, 0x2c, 0x4e, 0xc2, 0xab, 0x44, 0x5c, 0xfd, 0xd2, 0x00, 0xa4, 0x65, + 0x84, 0x53, 0xc3, 0xd8, 0x66, 0x63, 0x1f, + ], + [ + 0x7a, 0xb9, 0xd9, 0x45, 0x32, 0xdf, 0xde, 0x31, 0x8b, 0xc2, 0x85, 0xcc, 0xac, + 0xcf, 0x84, 0x1e, 0x0a, 0x1c, 0xcb, 0x7b, 0x5b, 0x62, 0x69, 0x40, 0x05, 0xea, + 0xfd, 0x44, 0x4e, 0x21, 0x82, 0xf2, + ], + [ + 0xcc, 0x71, 0xc7, 0xff, 0x3c, 0xd6, 0xbd, 0x00, 0x31, 0x00, 0xea, 0xeb, 0xbc, + 0x05, 0x93, 0x17, 0x43, 0x56, 0xae, 0xe7, 0x54, 0xfc, 0xe6, 0x74, 0x4c, 0x05, + 0xba, 0x9e, 0xd2, 0x9c, 0x93, 0xf0, 0x6d, 0x27, 0xbc, 0x2c, 0x5e, 0x7c, 0x60, + 0xfb, 0x23, 0xbf, 0x60, 0x72, 0xff, 0xe6, 0xde, 0x64, + ], + [ + 0x19, 0x13, 0x01, 0x29, 0xdb, 0x6b, 0xb0, 0xc5, 0x1a, 0x39, 0xb9, 0xa7, 0xfb, + 0xf3, 0xa7, 0x3e, 0x74, 0xae, 0x5f, 0x46, 0xfd, 0x0d, 0xda, 0x9e, 0x17, 0xc8, + 0xb8, 0xee, 0x36, 0x2b, 0x53, 0x6c, 0x46, 0xcb, 0xc2, 0x72, 0xb4, 0x6c, 0xc7, + 0x55, 0xa3, 0x7e, 0x5e, 0x39, 0x37, 0x03, 0x31, 0xf8, 0x31, 0x0f, 0xef, 0xc1, + 0x9c, 0x82, 0x91, 0x57, 0x85, 0x3c, 0x8c, 0x8e, 0x0c, 0x83, 0xc3, 0x23, + ] + ), + test_case!( + [0x51, 0x0f, 0x6a, 0x5e, 0x95, 0x09, 0x95,], + [ + 0x35, 0x9e, 0x21, 0xea, 0xa5, 0x98, 0x2a, 0x53, 0xcf, 0xcc, 0x3a, 0xbf, 0x65, + 0xfb, 0xa5, 0x8a, 0x0f, 0x72, 0x29, 0xa0, + ], + [ + 0x2c, 0x7b, 0xd8, 0x76, 0x53, 0xb2, 0x67, 0xfa, 0x35, 0x50, 0xf1, 0x94, 0xf3, + 0x65, 0xf8, 0x0f, 0x76, 0x51, 0xfb, 0x41, 0x25, 0xc3, 0xc0, 0x7a, 0xfe, 0x85, + 0x58, 0xb9, 0x30, 0xe2, 0x53, 0xc2, + ], + [ + 0xd0, 0x70, 0x84, 0x34, 0xe6, 0x5a, 0xf4, 0xb5, 0x66, 0xc8, 0x68, 0x68, 0xac, + 0xfd, 0x58, 0x1a, 0xae, 0xe0, 0x68, 0x80, 0xec, 0x2d, 0x5f, 0x22, 0x05, 0x1e, + 0xe3, 0x3e, 0x93, 0xb4, 0x72, 0x70, 0x1c, 0xae, 0x21, 0x8b, 0x03, 0xb7, 0x62, + 0x1a, 0xf5, 0x0b, 0xe4, 0x02, 0xbf, 0x5b, 0x5c, 0x2b, + ], + [ + 0x27, 0x6a, 0x6f, 0xf5, 0xed, 0xdf, 0xd4, 0x79, 0xa3, 0xd7, 0x7e, 0x0f, 0xe0, + 0xfe, 0x1a, 0xae, 0xd6, 0x28, 0xf1, 0xb3, 0xe5, 0x0c, 0x7b, 0x82, 0xcb, 0x69, + 0x06, 0xb5, 0xed, 0xd0, 0x66, 0x4f, 0xba, 0x38, 0x95, 0x67, 0x20, 0xe0, 0x18, + 0xe7, 0xa2, 0x14, 0x14, 0xbf, 0x8d, 0x03, 0xa9, 0x48, 0xf4, 0x44, 0x5f, 0x7d, + 0x19, 0xd7, 0x0e, 0xab, 0x01, 0xe2, 0x70, 0xfe, 0x56, 0xea, 0xc0, 0x1d, + ] + ), + test_case!( + [0x65, 0x2f, 0xd2, 0x1c, 0x7e, 0x7a, 0xcc, 0x2b,], + [ + 0x28, 0xfe, 0x15, 0xde, 0x85, 0x56, 0xb3, 0xd2, 0xc7, 0x20, 0x45, 0x0a, 0xed, + 0x3a, 0x9e, 0x7b, 0x2e, 0x27, 0xe4, 0xab, + ], + [ + 0x9c, 0xe7, 0x53, 0x27, 0x12, 0x0b, 0x72, 0x1f, 0xe3, 0x10, 0x60, 0x97, 0x3f, + 0x4b, 0xf8, 0x71, 0x77, 0x14, 0x57, 0xa3, 0x40, 0xfd, 0x00, 0xaa, 0x9c, 0x74, + 0xc5, 0xfd, 0x17, 0xc5, 0x09, 0xb6, + ], + [ + 0xcf, 0xc5, 0x9a, 0x8b, 0xd1, 0xa6, 0x73, 0x5e, 0x40, 0xee, 0xb6, 0x61, 0x1b, + 0x0a, 0xb3, 0x16, 0x7e, 0x95, 0xf7, 0x1a, 0xeb, 0x0e, 0x63, 0x2f, 0x56, 0x25, + 0x38, 0x89, 0xf4, 0xda, 0x40, 0x9e, 0xda, 0x9b, 0x80, 0x11, 0x4e, 0xb2, 0xf9, + 0x76, 0x30, 0x52, 0x50, 0x5e, 0x2a, 0xd0, 0x9d, 0x5f, + ], + [ + 0x82, 0xd4, 0x37, 0xbe, 0x30, 0xd7, 0x9e, 0x76, 0xec, 0x99, 0x47, 0x64, 0x06, + 0xc0, 0x32, 0x76, 0xdf, 0xeb, 0x5c, 0x72, 0x7e, 0xcd, 0x7d, 0x51, 0x86, 0x87, + 0x20, 0xb8, 0xd7, 0x1a, 0x93, 0x0c, 0x25, 0xb2, 0xa5, 0xd2, 0xa1, 0xbe, 0x1f, + 0xdc, 0x6b, 0x49, 0x1a, 0x62, 0x37, 0xfe, 0xe6, 0x34, 0x7c, 0x25, 0x3c, 0x2d, + 0xc8, 0x22, 0x51, 0x2b, 0x3b, 0x85, 0x6a, 0x77, 0x82, 0xd8, 0xf0, 0xf7, + ] + ), + test_case!( + [0x33, 0xde, 0x9a, 0x6f, 0x4b, 0x6e, 0x51, 0x44, 0x3b,], + [ + 0x35, 0x8c, 0x77, 0x96, 0xc5, 0xd5, 0xeb, 0xd6, 0xed, 0x5e, 0x8e, 0x38, 0xa0, + 0x3d, 0x73, 0x82, 0xf3, 0x82, 0xc9, 0x62, + ], + [ + 0x24, 0x96, 0xf0, 0xeb, 0xe4, 0xc3, 0x93, 0x00, 0xb7, 0xdf, 0xdc, 0xf3, 0xe2, + 0xcd, 0x37, 0xd8, 0x5b, 0x2b, 0xf1, 0x93, 0xdb, 0x83, 0xd7, 0x21, 0x98, 0x78, + 0xda, 0xb9, 0x7b, 0xb5, 0x82, 0xbb, + ], + [ + 0x3c, 0x5d, 0xff, 0x66, 0xfd, 0x9c, 0x53, 0xaa, 0x17, 0x98, 0x7d, 0x72, 0x94, + 0xff, 0x93, 0x44, 0xaf, 0x69, 0xd1, 0x56, 0x46, 0x0e, 0x49, 0x2d, 0xe7, 0xe5, + 0xa5, 0x99, 0x1f, 0x74, 0xc3, 0xdb, 0xe7, 0x13, 0x5c, 0x10, 0xf1, 0x25, 0xe4, + 0xbf, 0xda, 0x72, 0x96, 0xb6, 0x06, 0xb4, 0x48, 0x6b, + ], + [ + 0xde, 0xa9, 0x04, 0x76, 0x63, 0x59, 0xaa, 0x33, 0xc0, 0x9c, 0xb8, 0xb2, 0x76, + 0x37, 0x47, 0x52, 0x58, 0x71, 0x92, 0xf9, 0xb1, 0x90, 0xed, 0xc1, 0x8d, 0x42, + 0x97, 0x98, 0xe1, 0xe0, 0x1b, 0xdb, 0x87, 0x68, 0x6d, 0xd5, 0xea, 0x34, 0x0f, + 0xf6, 0x20, 0x8d, 0xa3, 0xbf, 0x6b, 0x27, 0x35, 0xf7, 0x0d, 0x72, 0x93, 0x74, + 0xab, 0xcf, 0xe9, 0xfc, 0xec, 0xb8, 0x36, 0x0c, 0x36, 0x75, 0xc0, 0x40, + ] + ), + test_case!( + [0x55, 0xc3, 0xd5, 0x66, 0x3c, 0x18, 0x19, 0x5e, 0x95, 0x6b,], + [ + 0x35, 0x63, 0xcf, 0x0a, 0xae, 0xc6, 0x33, 0x1e, 0x46, 0xc4, 0xb3, 0x3c, 0x1c, + 0xf3, 0x93, 0x3e, 0xe5, 0x90, 0xa3, 0xc3, + ], + [ + 0x05, 0x59, 0xaa, 0x90, 0xe0, 0x7d, 0x27, 0x46, 0x2c, 0x25, 0xc8, 0x82, 0xe4, + 0xc9, 0x65, 0xf3, 0x65, 0x9d, 0xdb, 0x25, 0x3e, 0x19, 0x8f, 0x39, 0x54, 0x47, + 0x99, 0x40, 0x3b, 0xd6, 0x8b, 0x2d, + ], + [ + 0xfe, 0xaf, 0x33, 0xaa, 0x94, 0x65, 0x45, 0xba, 0xf1, 0xb8, 0xee, 0xd2, 0xea, + 0xc2, 0x26, 0x1b, 0x87, 0x96, 0x6a, 0xd6, 0x5a, 0x13, 0xa4, 0x82, 0x7a, 0x92, + 0xed, 0xd9, 0xa8, 0xe3, 0xbe, 0x12, 0x6e, 0xc5, 0x99, 0xe9, 0xc5, 0x50, 0xea, + 0x01, 0xe2, 0x8e, 0xc4, 0xb9, 0x9b, 0x79, 0x9a, 0x10, + ], + [ + 0xdf, 0x32, 0xa2, 0x82, 0x4a, 0x6a, 0xfb, 0x64, 0x6e, 0xbb, 0xef, 0xc2, 0xab, + 0xeb, 0x7a, 0xac, 0xd1, 0x09, 0x97, 0xe4, 0xcc, 0x3b, 0x22, 0x66, 0x1f, 0x47, + 0x9e, 0x9d, 0x87, 0x42, 0xa3, 0x5e, 0x37, 0xd8, 0x6d, 0x83, 0x31, 0x79, 0x96, + 0x93, 0x4c, 0x04, 0x5f, 0x3d, 0x75, 0x99, 0x78, 0x71, 0xc3, 0x77, 0x1b, 0x67, + 0x2d, 0x15, 0x9a, 0x83, 0x6c, 0xc7, 0x13, 0x83, 0xb1, 0x76, 0xb1, 0x64, + ] + ), + test_case!( + [0x2c, 0xb1, 0xc2, 0xeb, 0xac, 0xe0, 0x7a, 0x32, 0x7d, 0xf0, 0x1a,], + [ + 0x9b, 0x8c, 0x27, 0xdc, 0x0d, 0x65, 0xc6, 0x9d, 0xce, 0x21, 0x2c, 0x99, 0x43, + 0xb5, 0x75, 0x11, 0x9a, 0x4d, 0x55, 0x5f, + ], + [ + 0x5a, 0xbe, 0x3b, 0x6d, 0x5b, 0x4d, 0x9f, 0x70, 0xca, 0x73, 0x66, 0x76, 0x63, + 0x86, 0xd0, 0x34, 0x1e, 0xe4, 0xb2, 0xff, 0x4d, 0x57, 0x40, 0xcf, 0xd5, 0x9a, + 0x84, 0x22, 0xf2, 0x53, 0x8c, 0x70, + ], + [ + 0x80, 0xd2, 0x9c, 0x92, 0x06, 0xfa, 0xc9, 0x06, 0xa0, 0xf1, 0x78, 0x7b, 0xe8, + 0x34, 0x65, 0xdf, 0x22, 0xec, 0xaf, 0x11, 0x3b, 0x88, 0x17, 0xba, 0x89, 0x83, + 0xe5, 0x71, 0x49, 0xd8, 0xa1, 0xdd, 0x3e, 0xb4, 0xa6, 0xcc, 0x90, 0xa7, 0xbe, + 0xad, 0xd0, 0xcb, 0x65, 0x53, 0xd5, 0x56, 0x39, 0x6f, + ], + [ + 0x21, 0x7f, 0x8e, 0xe2, 0x16, 0x05, 0x96, 0xd0, 0xd7, 0x12, 0x5d, 0xd2, 0x91, + 0x5d, 0xb9, 0xfd, 0x54, 0xac, 0x3d, 0xb3, 0x1e, 0x40, 0x0c, 0x29, 0xc5, 0x43, + 0x0b, 0xbd, 0x6b, 0x25, 0x82, 0x40, 0x0b, 0x05, 0xff, 0x73, 0xf3, 0xa3, 0x6d, + 0x75, 0xdd, 0xc2, 0xdf, 0x17, 0xb9, 0x45, 0xd4, 0x82, 0x26, 0x7a, 0x56, 0xe3, + 0xf0, 0x60, 0xe1, 0xe0, 0x54, 0x64, 0x34, 0x71, 0x32, 0x6d, 0x04, 0xcd, + ] + ), + test_case!( + [0x34, 0x3f, 0x7c, 0x83, 0x97, 0x7a, 0xd7, 0x5e, 0x19, 0x84, 0x99, 0xe2,], + [ + 0xd7, 0xdb, 0xef, 0x4a, 0xb6, 0x0e, 0x3a, 0x0a, 0xda, 0x14, 0x07, 0x50, 0xde, + 0xde, 0x23, 0xa6, 0xe1, 0x23, 0x96, 0x6d, + ], + [ + 0x2b, 0x7a, 0x77, 0x7b, 0x16, 0x52, 0x05, 0x7e, 0x9d, 0x0e, 0x31, 0x84, 0xf3, + 0x61, 0x43, 0x12, 0xd8, 0x6f, 0x65, 0xaa, 0xcc, 0x49, 0x53, 0xab, 0xa4, 0x26, + 0xd7, 0xf8, 0x4c, 0xfd, 0x90, 0x15, + ], + [ + 0x09, 0x7f, 0x80, 0x2a, 0xa2, 0xef, 0x2e, 0x1d, 0xce, 0xa0, 0x0e, 0x20, 0xde, + 0xe4, 0xe7, 0xd0, 0xa1, 0x85, 0x07, 0x7b, 0xec, 0x60, 0xeb, 0xe8, 0x23, 0x9a, + 0x15, 0x0d, 0x7c, 0x37, 0x19, 0x66, 0x73, 0x75, 0x2a, 0x42, 0x31, 0x8e, 0x13, + 0xe5, 0x13, 0x6c, 0xdf, 0x17, 0xde, 0x71, 0x2d, 0x29, + ], + [ + 0xb6, 0x64, 0xf9, 0x86, 0xbd, 0xd6, 0xa4, 0xda, 0x34, 0xcc, 0xcb, 0xbf, 0xc9, + 0xa8, 0x50, 0x1b, 0xa6, 0xee, 0x3a, 0xd4, 0xa8, 0x6a, 0x29, 0x4d, 0xe7, 0xd4, + 0xcb, 0x01, 0x31, 0x9e, 0xa9, 0x05, 0x36, 0x78, 0x6d, 0x79, 0xa0, 0xb3, 0xb1, + 0x02, 0x12, 0x78, 0x2e, 0x4a, 0x98, 0x02, 0x50, 0x62, 0xe1, 0xac, 0x0a, 0x28, + 0x90, 0x2e, 0xb4, 0x1b, 0xb2, 0xad, 0x0c, 0x38, 0x82, 0x5e, 0xde, 0x51, + ] + ), + test_case!( + [0xf6, 0x15, 0xa0, 0x82, 0x3c, 0x18, 0x48, 0x01, 0xd6, 0xd1, 0xa9, 0x67, 0xa4,], + [ + 0x46, 0x63, 0xa6, 0xcb, 0xab, 0xca, 0xd9, 0x28, 0x72, 0xee, 0x87, 0xa2, 0x39, + 0xab, 0x8d, 0x47, 0x49, 0x7f, 0x06, 0x38, + ], + [ + 0xf5, 0x57, 0xec, 0x18, 0xa9, 0xbe, 0x7d, 0x44, 0xef, 0xff, 0xf6, 0xcd, 0xab, + 0x40, 0x30, 0x5c, 0x98, 0x5c, 0x0e, 0x38, 0xe6, 0x1b, 0xac, 0x9d, 0xee, 0x51, + 0x24, 0x4e, 0xc1, 0xa6, 0x23, 0x0d, + ], + [ + 0xb7, 0x50, 0x8e, 0x49, 0x45, 0x53, 0x76, 0x6a, 0x46, 0xbd, 0x0f, 0x08, 0xea, + 0xa2, 0x15, 0x68, 0x59, 0xa3, 0x34, 0x25, 0x7a, 0x59, 0xbe, 0xa9, 0x0a, 0xf0, + 0xe7, 0x8c, 0xe8, 0xd2, 0x95, 0xd5, 0xfc, 0x96, 0xdd, 0x07, 0x1b, 0xde, 0x38, + 0x2c, 0xae, 0xbc, 0xae, 0x84, 0xe3, 0xa1, 0x69, 0xdf, + ], + [ + 0x68, 0xe9, 0xfd, 0xec, 0x46, 0x65, 0xc0, 0xdd, 0x3b, 0x88, 0x62, 0xc7, 0x3e, + 0x77, 0xee, 0xb3, 0xd4, 0x57, 0x7f, 0xb7, 0x65, 0x01, 0xe0, 0xeb, 0xa7, 0x55, + 0xbb, 0x98, 0xca, 0x4d, 0x1f, 0xe8, 0x22, 0xaf, 0x04, 0x8e, 0xdb, 0x8f, 0xd3, + 0x7c, 0x06, 0x3a, 0xcb, 0x49, 0x2f, 0xbf, 0xd5, 0x3d, 0x51, 0x3d, 0xb5, 0x50, + 0xbb, 0x26, 0xc8, 0x14, 0xd2, 0x62, 0x58, 0xb6, 0xe4, 0x1f, 0x39, 0x5f, + ] + ), + test_case!( + [ + 0xa7, 0xb5, 0x09, 0x64, 0x25, 0xf8, 0x20, 0xd0, 0x8a, 0xb9, 0x3c, 0xf8, 0x7c, + 0x8d, + ], + [ + 0x6c, 0xe1, 0x00, 0x85, 0x8d, 0x28, 0x61, 0x8f, 0x62, 0x7b, 0xfb, 0x3e, 0xe6, + 0x4f, 0x0c, 0xdb, 0x50, 0xcb, 0xef, 0xc1, + ], + [ + 0x49, 0x2a, 0x83, 0xb0, 0xaf, 0xf8, 0x83, 0x08, 0x43, 0xdc, 0x6f, 0xbe, 0x8b, + 0x14, 0xf7, 0x69, 0xad, 0x6b, 0x72, 0x97, 0x8f, 0xb9, 0xf8, 0xf5, 0x0a, 0x0e, + 0xb0, 0x1b, 0x99, 0x80, 0x3b, 0xb2, + ], + [ + 0xb3, 0x17, 0x37, 0x7d, 0x75, 0xde, 0xc7, 0x19, 0x6a, 0x56, 0xca, 0xe0, 0x37, + 0xa8, 0xd3, 0x08, 0xca, 0x04, 0x0e, 0x85, 0x14, 0x62, 0x1d, 0x6a, 0xe9, 0xfb, + 0x80, 0xf0, 0x8d, 0x0d, 0xc0, 0x89, 0x11, 0xef, 0xf0, 0x7a, 0xb8, 0x0f, 0x50, + 0x02, 0x5c, 0xf5, 0xc9, 0x62, 0x4a, 0x94, 0x9b, 0x0f, + ], + [ + 0x6d, 0xfc, 0x8f, 0x27, 0x92, 0x80, 0x09, 0x39, 0x32, 0xf1, 0x8d, 0x2f, 0xd9, + 0x8b, 0x8b, 0xa2, 0x53, 0x1c, 0x3e, 0x8b, 0x72, 0xb3, 0x55, 0xaa, 0x3b, 0x68, + 0xe7, 0x63, 0x6e, 0xbc, 0x03, 0xa7, 0x3f, 0x2e, 0xc2, 0x6c, 0x60, 0xae, 0xab, + 0x9d, 0xab, 0xfd, 0x3e, 0x05, 0x43, 0x9f, 0xaf, 0xd5, 0xf6, 0x3b, 0x75, 0xc6, + 0x72, 0xf5, 0x5e, 0x23, 0x55, 0x2d, 0x97, 0x26, 0xb6, 0xf3, 0x85, 0xe7, + ] + ), + test_case!( + [ + 0xd5, 0x74, 0x8a, 0xd1, 0xa3, 0x93, 0xd0, 0x09, 0xfb, 0xed, 0xee, 0x43, 0x7a, + 0x50, 0x49, + ], + [ + 0x13, 0x97, 0x62, 0x02, 0xbc, 0xc5, 0x6b, 0xd4, 0x33, 0xba, 0xca, 0x0e, 0xd6, + 0xa5, 0x47, 0x45, 0x4c, 0x9b, 0x06, 0xda, + ], + [ + 0xed, 0xdf, 0x3b, 0x8b, 0x62, 0x2f, 0xda, 0x42, 0x14, 0x86, 0x71, 0xe6, 0x86, + 0xac, 0x56, 0xd6, 0x91, 0x99, 0x4d, 0x88, 0x1c, 0x09, 0xf1, 0x2b, 0x73, 0x79, + 0x5f, 0x1b, 0x63, 0xf6, 0x86, 0xfe, + ], + [ + 0xa6, 0xeb, 0x40, 0xdc, 0x71, 0x9c, 0x20, 0xfb, 0xaa, 0x61, 0x16, 0xcd, 0x94, + 0xff, 0x9f, 0x60, 0x69, 0xfa, 0xee, 0x03, 0xb2, 0x1c, 0x1e, 0x59, 0xb0, 0xdd, + 0xff, 0xd7, 0x15, 0x45, 0xf2, 0x29, 0x24, 0x9d, 0x3e, 0x76, 0xc7, 0xf7, 0xd5, + 0x1d, 0xef, 0x9f, 0xc1, 0x78, 0x4e, 0x0a, 0xe7, 0xae, + ], + [ + 0x00, 0x0d, 0xfa, 0x4c, 0xb8, 0x07, 0x25, 0x75, 0x2f, 0x58, 0x50, 0xcc, 0x72, + 0xef, 0x10, 0x87, 0x28, 0xee, 0x6b, 0xb1, 0xe7, 0xe4, 0xe4, 0xfd, 0xeb, 0xd8, + 0xe8, 0xb9, 0x6b, 0xab, 0x92, 0xa8, 0x32, 0x1b, 0xb7, 0x55, 0x3b, 0x30, 0xc5, + 0x98, 0x97, 0x32, 0xea, 0xf2, 0x76, 0x84, 0x0b, 0x68, 0x32, 0xf8, 0x99, 0xcb, + 0x47, 0x63, 0x4b, 0x13, 0x16, 0x2c, 0x30, 0x13, 0xd3, 0x59, 0x93, 0xb0, + ] + ), + test_case!( + [ + 0x65, 0x2e, 0x60, 0xa1, 0x3d, 0xbf, 0x8e, 0xdb, 0x65, 0xc5, 0xd3, 0xce, 0x24, + 0xa8, 0x28, 0xbd, + ], + [ + 0xbe, 0x60, 0xc7, 0x04, 0xdd, 0x57, 0xf6, 0x42, 0xff, 0x59, 0x95, 0xba, 0xc6, + 0xdf, 0x42, 0x29, 0x86, 0xcb, 0x4d, 0x21, + ], + [ + 0x10, 0xa8, 0x99, 0xd3, 0x86, 0xea, 0xcb, 0xed, 0x95, 0x9f, 0x72, 0xac, 0x68, + 0xfb, 0x0c, 0x5b, 0x9f, 0x09, 0xf5, 0x3c, 0x57, 0xac, 0xe1, 0x2c, 0xe3, 0x1c, + 0xc0, 0x2e, 0x48, 0x39, 0x8f, 0x6a, + ], + [ + 0x2b, 0x80, 0xe6, 0xe2, 0xf7, 0x09, 0x59, 0xd1, 0xb6, 0x48, 0x07, 0x5b, 0x5b, + 0x30, 0x10, 0xb3, 0x49, 0xe2, 0xce, 0xf1, 0x13, 0x4d, 0x98, 0x4c, 0x3b, 0x83, + 0x93, 0xee, 0xb8, 0x4e, 0x10, 0x8a, 0xdd, 0x03, 0x2b, 0xaf, 0x5a, 0x2f, 0xe3, + 0x15, 0x35, 0xda, 0x7e, 0x9d, 0x14, 0xba, 0xbb, 0x77, + ], + [ + 0xc7, 0x3b, 0x61, 0xca, 0x99, 0xde, 0x4f, 0x17, 0x62, 0x51, 0xde, 0x80, 0x50, + 0xf9, 0x14, 0x11, 0x4d, 0xff, 0xa1, 0x84, 0x54, 0x2d, 0x89, 0xb4, 0x63, 0xda, + 0xfe, 0x25, 0x54, 0x91, 0x2d, 0xa9, 0xd9, 0xed, 0xd1, 0x33, 0xab, 0xea, 0xc9, + 0x06, 0xa7, 0x72, 0xb2, 0x80, 0x8b, 0xb2, 0x7a, 0x36, 0x60, 0x7d, 0xa9, 0x20, + 0x0b, 0x41, 0xfa, 0x68, 0xca, 0x2c, 0x80, 0x3a, 0x77, 0x5b, 0x22, 0x14, + ] + ), + test_case!( + [ + 0x9a, 0x7e, 0x4b, 0x4e, 0xe6, 0x80, 0xf6, 0x36, 0xa8, 0xf8, 0x71, 0xcd, 0xae, + 0xb8, 0xf9, 0xae, 0x23, + ], + [ + 0x7b, 0x32, 0xd0, 0x64, 0x68, 0x02, 0xc8, 0x4f, 0x41, 0xaa, 0xfc, 0xb2, 0xfc, + 0xbe, 0xed, 0x2a, 0xee, 0x93, 0x3f, 0x4f, + ], + [ + 0xea, 0x34, 0xbc, 0xd7, 0x7d, 0x84, 0xf3, 0x7f, 0x2f, 0x84, 0xeb, 0x04, 0xc9, + 0x00, 0xde, 0xd8, 0x5f, 0xd6, 0x4d, 0xbb, 0xc5, 0xed, 0x3c, 0x1f, 0x4d, 0x8e, + 0x77, 0x1e, 0xbb, 0xb5, 0x5c, 0xde, + ], + [ + 0xbe, 0x9a, 0x02, 0x3d, 0xa1, 0x3f, 0x26, 0xbb, 0x6d, 0xab, 0x4f, 0x57, 0xaa, + 0x90, 0x12, 0x2b, 0x10, 0x6f, 0xbc, 0x8c, 0xf8, 0xfb, 0x7b, 0x6a, 0x74, 0x1a, + 0xd7, 0xb4, 0xeb, 0x43, 0x12, 0x72, 0xb1, 0xec, 0x59, 0xdd, 0xe1, 0xda, 0x15, + 0x6f, 0xc3, 0x93, 0x04, 0xfb, 0xd0, 0x78, 0x61, 0x94, + ], + [ + 0xff, 0xda, 0x37, 0x32, 0x14, 0x3f, 0x97, 0x6f, 0xac, 0x64, 0x75, 0xb4, 0x8c, + 0x9c, 0xd9, 0x16, 0x87, 0x70, 0xd4, 0x27, 0xe9, 0x8e, 0x27, 0x2e, 0x7c, 0x08, + 0xc2, 0x21, 0x8c, 0xfe, 0x22, 0x5c, 0x39, 0xf0, 0x6c, 0x2a, 0x1d, 0x7e, 0x3e, + 0xa8, 0xeb, 0x39, 0xd2, 0xcd, 0x78, 0x8d, 0x2f, 0x6d, 0x13, 0xee, 0x16, 0x31, + 0x46, 0x06, 0xf0, 0xf2, 0x5b, 0x03, 0xc7, 0x11, 0xec, 0x33, 0x59, 0xd8, + ] + ), + test_case!( + [ + 0xe4, 0x20, 0x5c, 0x7c, 0x8e, 0x25, 0x00, 0xc4, 0x3e, 0x8b, 0xfb, 0x19, 0x68, + 0x63, 0xa6, 0x2e, 0xc7, 0x23, + ], + [ + 0xaa, 0x6c, 0xb1, 0x6b, 0xf8, 0x21, 0x74, 0x19, 0x9e, 0x96, 0xf6, 0xbd, 0xc5, + 0xad, 0x67, 0x5d, 0x06, 0x09, 0x3b, 0x28, + ], + [ + 0x88, 0x49, 0x1d, 0xec, 0x62, 0x4e, 0x51, 0xad, 0xd9, 0xc0, 0xce, 0xf3, 0x7c, + 0x99, 0x98, 0x43, 0x5d, 0x04, 0x7c, 0xdf, 0xa2, 0x3e, 0x22, 0xbf, 0x34, 0x2a, + 0x66, 0x77, 0xe0, 0x19, 0x2f, 0xe5, + ], + [ + 0x10, 0x59, 0xba, 0x48, 0x0e, 0xfd, 0xc0, 0x69, 0x20, 0x52, 0xe1, 0xa5, 0xe8, + 0xf3, 0xa6, 0x69, 0x88, 0xb6, 0x35, 0xd7, 0x2d, 0x14, 0x42, 0x87, 0x25, 0x1e, + 0x02, 0xfe, 0xbe, 0x58, 0x43, 0x36, 0xdc, 0xe7, 0xfd, 0xfd, 0x0f, 0x2a, 0x39, + 0x13, 0x60, 0x39, 0xad, 0xd8, 0x38, 0x13, 0x5d, 0x6c, + ], + [ + 0xa9, 0x01, 0xf4, 0xc6, 0xe9, 0x6c, 0x8e, 0x76, 0xd1, 0xcb, 0xfa, 0x50, 0xa6, + 0x24, 0x8a, 0x0f, 0xdf, 0x64, 0x0e, 0xda, 0xc4, 0xf0, 0x79, 0xf0, 0x46, 0xaa, + 0x63, 0xc7, 0x8c, 0xf3, 0xce, 0xe1, 0x28, 0x7b, 0x03, 0x63, 0x47, 0xd4, 0x40, + 0xf8, 0x1f, 0x38, 0x09, 0x06, 0xd5, 0x86, 0x80, 0x21, 0x2a, 0x4d, 0x9d, 0x27, + 0xbf, 0xbf, 0xbe, 0x4e, 0x6c, 0x37, 0x5e, 0x89, 0xfa, 0x41, 0xe4, 0xe7, + ] + ), + test_case!( + [ + 0x57, 0xc3, 0x48, 0x43, 0x9a, 0x40, 0xb4, 0x4a, 0x06, 0xff, 0x22, 0x1d, 0x90, + 0xed, 0x22, 0xa4, 0x8a, 0x03, 0x21, + ], + [ + 0xd2, 0x4b, 0x43, 0xd6, 0x06, 0x63, 0x34, 0xf6, 0xf8, 0x2c, 0x5f, 0xca, 0xd2, + 0x85, 0x53, 0xa5, 0xed, 0x8a, 0x51, 0xec, + ], + [ + 0xcd, 0x99, 0x4a, 0x59, 0x55, 0xff, 0x36, 0x74, 0xe5, 0xbe, 0x99, 0xd2, 0x32, + 0x63, 0x6e, 0x93, 0x57, 0xf1, 0xad, 0x7c, 0x68, 0x5a, 0x54, 0xdb, 0xce, 0x62, + 0xe7, 0xd8, 0xa0, 0x64, 0xbb, 0xed, + ], + [ + 0xf2, 0x0d, 0x8e, 0x2a, 0x00, 0x38, 0xfc, 0x4e, 0xaa, 0xcb, 0x70, 0xe0, 0xcd, + 0xc8, 0x37, 0x5b, 0x35, 0x62, 0x4b, 0x65, 0xa5, 0xfc, 0x57, 0x52, 0xa1, 0x48, + 0x54, 0xd2, 0x56, 0x73, 0x43, 0xad, 0xac, 0xfd, 0xda, 0x3f, 0xa6, 0x00, 0x1c, + 0x46, 0x4a, 0xad, 0xea, 0x1e, 0x79, 0x73, 0x03, 0x05, + ], + [ + 0x1e, 0x60, 0x4f, 0x67, 0xd6, 0xb4, 0xf5, 0x79, 0x4a, 0x5d, 0x8f, 0x81, 0x82, + 0xe1, 0x2a, 0x98, 0x00, 0x31, 0x3a, 0x2a, 0x5c, 0x1f, 0xc0, 0x21, 0xc8, 0xc2, + 0x6d, 0x89, 0x94, 0x2e, 0x91, 0x59, 0x8d, 0x58, 0x71, 0x82, 0x11, 0xc8, 0xc2, + 0x32, 0x42, 0x75, 0xcb, 0x18, 0x57, 0x1c, 0x1a, 0x77, 0x87, 0x0a, 0x60, 0xe6, + 0xbc, 0x89, 0xc6, 0x8e, 0x2f, 0x5d, 0x81, 0x51, 0xeb, 0xbb, 0x1f, 0x2d, + ] + ), + test_case!( + [ + 0x07, 0x88, 0x5e, 0xe1, 0x7d, 0x31, 0x35, 0x5a, 0x13, 0xa8, 0x36, 0xac, 0xd1, + 0x95, 0xff, 0x0b, 0x99, 0x22, 0x5c, 0x2a, + ], + [ + 0x05, 0xf0, 0x1f, 0xea, 0x63, 0xd9, 0x27, 0x6d, 0xa4, 0x19, 0xce, 0xaa, 0xad, + 0x29, 0xbd, 0x95, 0xd7, 0x51, 0x1e, 0xde, + ], + [ + 0xb5, 0x3d, 0x9d, 0x4d, 0x15, 0x6b, 0xa6, 0xf6, 0x30, 0x69, 0x3b, 0xfd, 0xe1, + 0x6f, 0x4d, 0x8b, 0xe7, 0xa6, 0xc8, 0x35, 0x6f, 0xbc, 0x38, 0xb4, 0x43, 0x99, + 0x55, 0xef, 0x56, 0x9e, 0xce, 0x5a, + ], + [ + 0xc7, 0x14, 0xd0, 0x55, 0xbc, 0x24, 0xee, 0xca, 0x91, 0x3f, 0xf8, 0x5e, 0x78, + 0x29, 0xca, 0xcc, 0x3d, 0xe9, 0x4e, 0xdb, 0x56, 0x69, 0x74, 0x14, 0x83, 0xf8, + 0xec, 0x27, 0xc2, 0xdb, 0x09, 0xab, 0x69, 0x5f, 0x09, 0x71, 0x2a, 0xcf, 0x4a, + 0xc9, 0x90, 0xa8, 0x00, 0x18, 0x96, 0x82, 0x97, 0x9b, + ], + [ + 0x12, 0x9a, 0xfb, 0x1a, 0x2d, 0x1d, 0xee, 0x3a, 0x68, 0x6c, 0x7f, 0xea, 0x9e, + 0x1d, 0xb0, 0x97, 0x39, 0x5f, 0x94, 0x96, 0x24, 0xea, 0xb1, 0x73, 0x5f, 0x2a, + 0xa8, 0x10, 0xaa, 0x95, 0xae, 0xc4, 0x5e, 0x22, 0x5c, 0x17, 0xf8, 0x12, 0x51, + 0x7d, 0x75, 0xaa, 0x3d, 0x6c, 0x85, 0xdf, 0x81, 0x2f, 0xc1, 0xdd, 0x00, 0x50, + 0xb8, 0xd1, 0x47, 0xf5, 0x7e, 0xf9, 0xa1, 0xd0, 0xd6, 0x9f, 0xa6, 0xd9, + ] + ), + test_case!( + [ + 0xf0, 0x00, 0x1a, 0xf6, 0x9a, 0xf1, 0x96, 0x07, 0x58, 0x0b, 0x2f, 0xad, 0x1d, + 0xfe, 0x5e, 0x0b, 0x92, 0xe9, 0x97, 0xcb, 0x64, + ], + [ + 0x77, 0x7c, 0xcf, 0xaa, 0x8d, 0xd8, 0xfc, 0x1f, 0xed, 0x83, 0x5c, 0xfe, 0xd5, + 0xbd, 0x5d, 0x18, 0x6d, 0xd8, 0xfd, 0x1a, + ], + [ + 0x1c, 0x92, 0x99, 0xee, 0x27, 0xf2, 0xaa, 0x93, 0xd4, 0x9f, 0x79, 0x43, 0xb0, + 0xaf, 0x91, 0xf6, 0x16, 0xbb, 0xeb, 0x3d, 0x2d, 0xe6, 0x9e, 0xfa, 0xe9, 0x2f, + 0x13, 0xec, 0xdf, 0xd9, 0x41, 0x7b, + ], + [ + 0x4a, 0x54, 0x8b, 0x22, 0xb6, 0x6e, 0x73, 0x22, 0xd0, 0xd6, 0x1b, 0x5b, 0xf2, + 0x3f, 0xd2, 0x80, 0xf6, 0x72, 0xec, 0x37, 0x68, 0x71, 0xef, 0x88, 0x66, 0xad, + 0xa5, 0xb4, 0x5a, 0xf2, 0x01, 0x15, 0x3b, 0x59, 0xd4, 0xdd, 0x6d, 0x24, 0x67, + 0x95, 0x2b, 0xd2, 0xb1, 0x75, 0xf1, 0x1b, 0xb9, 0x4e, + ], + [ + 0x29, 0x79, 0xe6, 0x0d, 0x8c, 0x0f, 0x5b, 0x4b, 0xad, 0xba, 0x4b, 0xac, 0xea, + 0x92, 0x4b, 0x4f, 0x74, 0x74, 0xb9, 0x85, 0xca, 0x84, 0xfa, 0x9e, 0xdd, 0xe0, + 0x02, 0x0a, 0x94, 0x22, 0x76, 0xb5, 0x48, 0x3d, 0xd2, 0x97, 0xe2, 0xa4, 0x0c, + 0xcd, 0x99, 0x50, 0x3b, 0xe4, 0x51, 0xb8, 0x45, 0x40, 0xc9, 0x88, 0xc7, 0x73, + 0xda, 0x78, 0x33, 0x24, 0xf2, 0xf4, 0x4f, 0x87, 0x0c, 0xa2, 0xd0, 0xdf, + ] + ), + test_case!( + [ + 0xc1, 0xe2, 0x99, 0xa7, 0xa2, 0x5b, 0xb9, 0x05, 0x74, 0x3f, 0x50, 0x09, 0xfd, + 0x56, 0x25, 0x41, 0x93, 0xdd, 0xa7, 0xe1, 0x67, 0xa5, + ], + [ + 0xbd, 0xfb, 0xae, 0x49, 0x43, 0x93, 0xa2, 0xfa, 0xeb, 0xbc, 0x30, 0x10, 0x06, + 0x5a, 0x7e, 0x3c, 0x31, 0x0d, 0x8a, 0xf5, + ], + [ + 0x25, 0x21, 0x22, 0xe2, 0x0e, 0xfc, 0x1d, 0xbe, 0x89, 0xcd, 0x03, 0xfe, 0x97, + 0x2f, 0x19, 0xd6, 0x65, 0x95, 0x65, 0xe6, 0x39, 0x7d, 0x2e, 0x06, 0xea, 0x95, + 0xc3, 0xc6, 0x92, 0xe0, 0x66, 0xbe, + ], + [ + 0x38, 0x8a, 0x92, 0x99, 0x7c, 0xa3, 0x4e, 0x55, 0xf3, 0xf5, 0x3f, 0x70, 0xff, + 0xa6, 0x5d, 0x66, 0xda, 0xeb, 0x1e, 0x27, 0x34, 0xce, 0xd7, 0x21, 0xdc, 0xbc, + 0xcd, 0x23, 0x1a, 0x6e, 0xfe, 0x67, 0x1f, 0x36, 0x2f, 0x9f, 0x25, 0xc1, 0xb8, + 0x76, 0x7c, 0x05, 0xac, 0x3c, 0xd1, 0xb7, 0x96, 0xd1, + ], + [ + 0x9a, 0x28, 0x69, 0x0f, 0x6b, 0xfe, 0x1f, 0x09, 0xc3, 0x09, 0x9e, 0x58, 0x9f, + 0x63, 0x83, 0xc7, 0x01, 0xa4, 0xab, 0x7f, 0xbd, 0xcc, 0x64, 0x5e, 0xda, 0xd1, + 0x38, 0xdd, 0x3e, 0x72, 0xa6, 0x39, 0xff, 0x8e, 0xcc, 0xa4, 0xa8, 0xe4, 0xd6, + 0x98, 0x03, 0x83, 0xb6, 0xec, 0x22, 0x07, 0x7e, 0x54, 0x23, 0x1b, 0x5b, 0x47, + 0x0b, 0x2a, 0x17, 0x88, 0x51, 0x04, 0x5d, 0x33, 0xe4, 0xa4, 0xda, 0x36, + ] + ), + test_case!( + [ + 0xf3, 0xcb, 0xac, 0x95, 0xfd, 0x74, 0x21, 0xa8, 0x25, 0x21, 0xe4, 0x4e, 0x2f, + 0x4f, 0x11, 0xe2, 0xc1, 0xf6, 0xe2, 0x87, 0xcb, 0x1c, 0xa8, + ], + [ + 0xb1, 0x8a, 0x12, 0x63, 0x33, 0x5e, 0xa3, 0xdf, 0x65, 0x6a, 0x38, 0x13, 0xe3, + 0xd9, 0x1b, 0x32, 0xc9, 0xe2, 0x59, 0xfe, + ], + [ + 0x33, 0x12, 0x28, 0x64, 0x7c, 0xf0, 0x63, 0xf7, 0xc9, 0x45, 0x39, 0x17, 0x18, + 0x14, 0xa0, 0x6c, 0xb3, 0xab, 0x85, 0x4f, 0x8c, 0xbd, 0x56, 0xc6, 0x76, 0x31, + 0x67, 0x66, 0x39, 0xdc, 0xd5, 0xc4, + ], + [ + 0x62, 0xf9, 0xdd, 0x10, 0xfa, 0xf2, 0xbf, 0xa4, 0x13, 0xf2, 0x46, 0xb6, 0x11, + 0x88, 0x97, 0x9e, 0x21, 0xef, 0x94, 0x7b, 0x34, 0x73, 0xa3, 0x43, 0x94, 0x3c, + 0xc3, 0xcc, 0x3a, 0xe8, 0x93, 0x26, 0xb1, 0xee, 0x51, 0x43, 0xa6, 0x82, 0x77, + 0x35, 0x7c, 0x43, 0xff, 0xa5, 0xac, 0x27, 0x97, 0x3e, + ], + [ + 0x3d, 0xdf, 0x7a, 0x6b, 0xa5, 0x15, 0xaa, 0x68, 0xc4, 0x2f, 0x3b, 0xce, 0x60, + 0x65, 0xde, 0x58, 0x42, 0x03, 0xe0, 0x80, 0x61, 0xc7, 0x87, 0xb1, 0x2c, 0xbd, + 0xd2, 0x61, 0x06, 0x6a, 0x04, 0xd4, 0x2c, 0xa9, 0x4a, 0xc0, 0x84, 0x3b, 0xfa, + 0xe5, 0x83, 0x19, 0x8f, 0x4c, 0x1f, 0x69, 0x6b, 0xf1, 0xbc, 0x2e, 0x9f, 0x4c, + 0xdf, 0xc9, 0xf6, 0x9c, 0x2a, 0xd2, 0x80, 0x5b, 0xd2, 0x4f, 0xf9, 0x14, + ] + ), + test_case!( + [ + 0x1a, 0x5e, 0x44, 0xf6, 0x69, 0x86, 0xbf, 0x9d, 0x21, 0x08, 0xd8, 0x6e, 0xd2, + 0x7c, 0xc4, 0x1c, 0xa7, 0x9e, 0xc9, 0x7e, 0x06, 0x61, 0x7f, 0x79, + ], + [ + 0xa7, 0x21, 0x10, 0x5f, 0xe3, 0x34, 0xe3, 0xe7, 0x21, 0x65, 0x66, 0xd7, 0xe0, + 0x8b, 0x32, 0xd5, 0x86, 0x80, 0x90, 0x85, + ], + [ + 0xa5, 0xe2, 0x8a, 0xc0, 0x37, 0xb9, 0x04, 0x8b, 0xd5, 0x75, 0x29, 0x95, 0xfb, + 0x18, 0x8d, 0x64, 0xa2, 0xc5, 0x39, 0x80, 0x57, 0x57, 0x10, 0x90, 0x1e, 0x5e, + 0x90, 0xaa, 0x95, 0x8c, 0xa4, 0x9a, + ], + [ + 0xd4, 0x5f, 0x14, 0xef, 0xec, 0x90, 0x63, 0x39, 0x71, 0xa1, 0x7e, 0xc0, 0xfe, + 0x00, 0x7a, 0xde, 0xb6, 0x52, 0x27, 0x3d, 0xea, 0x63, 0x82, 0xdb, 0x27, 0x78, + 0xce, 0x1a, 0x1e, 0xdb, 0x29, 0x1d, 0xaf, 0xa2, 0x64, 0xee, 0x2d, 0x42, 0x8d, + 0x80, 0xb4, 0x6a, 0x3b, 0x8a, 0x96, 0x93, 0x24, 0xfa, + ], + [ + 0x11, 0xac, 0xa6, 0x8c, 0x19, 0xa3, 0xa9, 0xbe, 0xea, 0xb6, 0xc0, 0x8e, 0x7c, + 0x5f, 0x33, 0xf5, 0xe8, 0x0d, 0xc0, 0x3c, 0x16, 0x27, 0xad, 0x23, 0xdf, 0x24, + 0x0b, 0xeb, 0xb6, 0x1e, 0x41, 0xae, 0x07, 0xdc, 0xa9, 0xeb, 0x10, 0xff, 0x3c, + 0xfd, 0xab, 0xcf, 0xac, 0x1c, 0xbe, 0x29, 0xbc, 0xf3, 0x4f, 0x53, 0x9c, 0x20, + 0x9a, 0xb6, 0x58, 0x98, 0x3a, 0xa5, 0x44, 0xec, 0x2f, 0xc9, 0xd0, 0x0a, + ] + ), + test_case!( + [ + 0x4f, 0xe1, 0xfa, 0x85, 0x10, 0xf8, 0x1e, 0x6a, 0xea, 0xc0, 0xb1, 0xd7, 0xc8, + 0x83, 0x51, 0x99, 0x6e, 0x62, 0xb7, 0x39, 0x2a, 0x20, 0x10, 0xac, 0xb9, + ], + [ + 0xff, 0x2e, 0x33, 0x8f, 0x1e, 0x06, 0x4e, 0x90, 0xd6, 0x30, 0x38, 0x81, 0x55, + 0x35, 0x48, 0x71, 0x9f, 0xd5, 0x72, 0x9a, + ], + [ + 0x71, 0x38, 0x91, 0x14, 0x63, 0x80, 0xaf, 0x21, 0x0a, 0x44, 0x9f, 0xf4, 0x8e, + 0x6f, 0x28, 0xbf, 0x72, 0xec, 0x85, 0x17, 0x4d, 0x63, 0xc7, 0x99, 0xd3, 0xb5, + 0x35, 0xc0, 0x84, 0xb2, 0x39, 0xd1, + ], + [ + 0x7e, 0x7b, 0x46, 0xa4, 0xd4, 0x08, 0x18, 0xb9, 0x2e, 0xbd, 0x41, 0x4d, 0x19, + 0xb6, 0xe1, 0x57, 0x95, 0xd5, 0x4f, 0x28, 0x92, 0x40, 0xcc, 0x8c, 0x32, 0x78, + 0xbe, 0x59, 0xc3, 0x72, 0x9b, 0x75, 0xcf, 0xbe, 0xfa, 0x37, 0x61, 0xa0, 0x3e, + 0xd6, 0x24, 0x30, 0xeb, 0xa1, 0x32, 0x30, 0xd4, 0x90, + ], + [ + 0x51, 0x6a, 0xd6, 0x0e, 0xea, 0xbb, 0x6d, 0x9e, 0xf3, 0x64, 0x9a, 0x2c, 0xe9, + 0xdc, 0x29, 0x5e, 0x7a, 0x5d, 0x21, 0xa2, 0x5c, 0x11, 0x56, 0xc1, 0x74, 0xae, + 0x9c, 0xb7, 0x8c, 0x28, 0x11, 0xa4, 0x5d, 0x8b, 0x55, 0xd8, 0xd3, 0x61, 0xb7, + 0x9f, 0x18, 0xc5, 0x55, 0xe1, 0x5b, 0x80, 0x15, 0x4b, 0x51, 0x15, 0x93, 0x38, + 0x02, 0xd8, 0x45, 0x2f, 0x86, 0x3a, 0x4d, 0xb8, 0xa3, 0x71, 0xa9, 0x49, + ] + ), + test_case!( + [ + 0xa8, 0x08, 0x67, 0x1e, 0x27, 0x35, 0x1e, 0x56, 0x2d, 0x57, 0xa5, 0xce, 0xa8, + 0x5b, 0x7e, 0x7b, 0xb2, 0x2c, 0x85, 0x1b, 0x2e, 0xc5, 0x44, 0x65, 0x1e, 0x87, + ], + [ + 0xe0, 0x44, 0xb2, 0x0a, 0x1f, 0x0b, 0x28, 0xe4, 0x30, 0xc9, 0x79, 0xec, 0x3e, + 0xf9, 0x5f, 0x27, 0xb5, 0x7d, 0xc6, 0x22, + ], + [ + 0xf8, 0x07, 0x78, 0xc1, 0x7f, 0x0b, 0x44, 0x7b, 0xe7, 0xba, 0x56, 0x29, 0x78, + 0xdb, 0xb6, 0xde, 0x07, 0x09, 0x4a, 0x9a, 0x3c, 0x84, 0x71, 0x8e, 0xde, 0x0e, + 0x67, 0x85, 0xbb, 0xf0, 0x87, 0xfb, + ], + [ + 0x6b, 0xd2, 0x50, 0xa8, 0x80, 0xc1, 0x74, 0xa0, 0x2c, 0xd8, 0x11, 0x29, 0x33, + 0x11, 0x7a, 0x37, 0x19, 0x39, 0x7a, 0x30, 0x01, 0xe8, 0xbc, 0x85, 0x0f, 0x07, + 0xb5, 0xcd, 0xb4, 0x08, 0x81, 0xc4, 0x84, 0x2b, 0x83, 0x36, 0xaa, 0x48, 0xf0, + 0x1c, 0x38, 0x1f, 0x2a, 0x35, 0x45, 0x28, 0x77, 0x10, + ], + [ + 0xf7, 0x98, 0xa7, 0x6b, 0xb6, 0x16, 0xf2, 0xec, 0xa0, 0x9a, 0xe2, 0x2b, 0xf4, + 0x79, 0x45, 0xfe, 0x46, 0x3b, 0x91, 0x12, 0x48, 0xc5, 0xa3, 0xcb, 0xe6, 0x14, + 0xfe, 0x6b, 0x5b, 0x30, 0xd1, 0x5a, 0x3a, 0x85, 0x58, 0xa2, 0x95, 0x4c, 0x04, + 0x09, 0x69, 0x51, 0xe1, 0x11, 0x09, 0xcc, 0x79, 0xea, 0x4d, 0x4f, 0x07, 0x38, + 0x9c, 0x58, 0x4e, 0x00, 0x54, 0xfd, 0x2f, 0xb2, 0xa4, 0x5b, 0x98, 0xc2, + ] + ), + test_case!( + [ + 0x33, 0xb8, 0xf5, 0xfd, 0xb6, 0x39, 0x2c, 0xea, 0x31, 0xd8, 0x33, 0x36, 0xf8, + 0x84, 0xfc, 0x23, 0x16, 0xa3, 0x4e, 0xe4, 0xf8, 0x21, 0xb5, 0x55, 0xa8, 0x83, + 0x8d, + ], + [ + 0xb7, 0x2c, 0x8f, 0x31, 0xd5, 0xed, 0x7b, 0x75, 0x37, 0x72, 0x47, 0xc2, 0x6d, + 0x66, 0x96, 0xb6, 0x4c, 0xc4, 0x0a, 0xfa, + ], + [ + 0xca, 0x6e, 0xaa, 0xc3, 0x73, 0x5b, 0x62, 0x4d, 0xa5, 0x12, 0x80, 0x92, 0x92, + 0x74, 0xcf, 0x53, 0x44, 0x8b, 0x05, 0xeb, 0x27, 0x40, 0xda, 0xe7, 0xf6, 0x9b, + 0x59, 0xa3, 0xca, 0x2e, 0xe4, 0x8a, + ], + [ + 0xad, 0x90, 0xe4, 0x59, 0x3f, 0x71, 0x8a, 0xc3, 0x77, 0xd0, 0x55, 0xc2, 0xe5, + 0x4e, 0x3d, 0x96, 0x6f, 0xe3, 0xcf, 0x0f, 0xae, 0x79, 0xbc, 0xaa, 0x11, 0x74, + 0x46, 0xcd, 0x2c, 0x1b, 0xdf, 0xbf, 0xd6, 0x5f, 0x05, 0xea, 0x64, 0xae, 0xc7, + 0xd3, 0xbe, 0x55, 0xb9, 0xad, 0xc3, 0x22, 0x4a, 0xa3, + ], + [ + 0x4d, 0x60, 0x6c, 0x85, 0xbc, 0x45, 0xdf, 0xf1, 0xc1, 0xb6, 0xd2, 0x97, 0x09, + 0x7e, 0xb9, 0x13, 0x16, 0xeb, 0x27, 0x20, 0xeb, 0xd1, 0x9a, 0xf4, 0xad, 0x52, + 0x80, 0xde, 0xdd, 0x2b, 0xce, 0x6f, 0x29, 0xbc, 0x9b, 0x65, 0xd1, 0x64, 0xf1, + 0x71, 0x77, 0x6e, 0x36, 0x76, 0xbb, 0x51, 0xc0, 0xcc, 0x79, 0x2e, 0xee, 0xe0, + 0x7b, 0x47, 0x11, 0x75, 0xa0, 0x44, 0x36, 0x75, 0x4a, 0xd5, 0x2a, 0xc5, + ] + ), + test_case!( + [ + 0xfb, 0x75, 0xd7, 0x72, 0x25, 0xfa, 0xd8, 0x4b, 0x98, 0x3d, 0x0f, 0xcc, 0xf9, + 0x8d, 0xfd, 0xbf, 0x35, 0x97, 0x3e, 0xb5, 0xbb, 0xf0, 0xf6, 0x1a, 0xa3, 0x2b, + 0x22, 0x67, + ], + [ + 0xa9, 0xb6, 0x45, 0xdf, 0x54, 0x3b, 0x53, 0xd6, 0x92, 0x3f, 0x32, 0x80, 0xae, + 0x7c, 0x5f, 0x8b, 0xa5, 0x8a, 0x62, 0x1d, + ], + [ + 0x1d, 0x78, 0xba, 0x8f, 0x84, 0xa6, 0x36, 0xf0, 0x1e, 0xf4, 0x2a, 0x6a, 0x67, + 0xec, 0x22, 0x4a, 0x59, 0xf2, 0x04, 0x5d, 0x65, 0xda, 0x35, 0x74, 0x91, 0x3f, + 0x04, 0xbc, 0x9c, 0x25, 0x55, 0xf4, + ], + [ + 0xfa, 0xd9, 0x9f, 0x14, 0x94, 0xf5, 0xa9, 0x8e, 0x0d, 0x21, 0xb4, 0xd1, 0x6c, + 0x28, 0x82, 0x2c, 0x71, 0x67, 0xc7, 0x31, 0xe1, 0xb3, 0x48, 0xec, 0xa5, 0xe1, + 0x36, 0xdb, 0x15, 0x06, 0x83, 0x30, 0x67, 0xd3, 0x3e, 0x29, 0x57, 0xe9, 0xe3, + 0x8f, 0xae, 0x75, 0xbc, 0x91, 0x8e, 0x08, 0xc9, 0xe2, + ], + [ + 0x37, 0x50, 0x62, 0x23, 0x99, 0x49, 0x37, 0x64, 0xbe, 0xc3, 0xe6, 0x23, 0xaf, + 0x9d, 0x9a, 0xc2, 0x48, 0x0d, 0x6d, 0x35, 0x3a, 0x0e, 0x2d, 0x29, 0xae, 0x06, + 0x2f, 0x2e, 0x51, 0xeb, 0xaf, 0xea, 0x08, 0x8e, 0x6c, 0xde, 0x9b, 0x10, 0x8d, + 0xee, 0xf3, 0xfa, 0xbc, 0xc3, 0x22, 0xb7, 0xec, 0x93, 0x18, 0x0a, 0xaa, 0x63, + 0xd8, 0xe1, 0x18, 0x03, 0xe5, 0x67, 0xab, 0x24, 0xd3, 0x42, 0x5f, 0x64, + ] + ), + test_case!( + [ + 0xca, 0xf3, 0x50, 0x61, 0x4a, 0x0e, 0xf6, 0xcb, 0x1e, 0x8c, 0x8c, 0x31, 0xa9, + 0x4d, 0x85, 0x6a, 0xef, 0x80, 0x94, 0x1f, 0x56, 0x24, 0xde, 0x64, 0x44, 0x14, + 0x8a, 0x51, 0x65, + ], + [ + 0x53, 0xc9, 0x5a, 0x79, 0xf8, 0x1c, 0x7f, 0xb3, 0x3b, 0xf6, 0x6a, 0x62, 0xee, + 0x03, 0xd5, 0xc3, 0x69, 0x2b, 0x87, 0x00, + ], + [ + 0xbd, 0xe7, 0xf3, 0xc4, 0xe9, 0xff, 0xc1, 0x80, 0xb8, 0xa1, 0x9f, 0x5e, 0xb5, + 0x23, 0xdd, 0x31, 0xaa, 0x50, 0x27, 0xaf, 0x27, 0x02, 0x5d, 0xc1, 0xb1, 0x56, + 0x11, 0x02, 0xce, 0x85, 0xdb, 0x00, + ], + [ + 0x1e, 0x38, 0x5d, 0x8b, 0x67, 0x0a, 0x21, 0xf5, 0x7d, 0xb7, 0x75, 0x4a, 0xa1, + 0x94, 0x3c, 0xd8, 0xfb, 0x51, 0xf1, 0x5f, 0x01, 0xd6, 0x88, 0x45, 0x4a, 0x26, + 0x43, 0xb7, 0xe7, 0x40, 0xb1, 0xf9, 0xa7, 0xb6, 0x41, 0x1c, 0x45, 0xed, 0x68, + 0x07, 0xf6, 0xc2, 0x9f, 0xb3, 0x5a, 0x2e, 0x23, 0x1d, + ], + [ + 0x43, 0xb3, 0xde, 0xb1, 0x2d, 0x5c, 0x96, 0x29, 0x5a, 0x80, 0x57, 0xb6, 0x0d, + 0x8c, 0x7b, 0x03, 0x86, 0xd3, 0x4b, 0x87, 0x9d, 0xe5, 0xd0, 0xa5, 0xa9, 0x78, + 0xa8, 0x2a, 0x6a, 0x7c, 0x4f, 0xd7, 0x69, 0x18, 0x32, 0x72, 0x72, 0x8a, 0xa5, + 0xc5, 0x90, 0x1f, 0xf9, 0x1e, 0x72, 0xbb, 0x38, 0x81, 0x66, 0x6e, 0xd3, 0x8d, + 0x22, 0x44, 0x35, 0x00, 0x27, 0xe7, 0xb1, 0x0d, 0x44, 0x00, 0x02, 0x18, + ] + ), + test_case!( + [ + 0x45, 0xc2, 0x69, 0x41, 0xac, 0x58, 0xb9, 0xa2, 0x6f, 0xc3, 0xe1, 0x2b, 0x47, + 0x1e, 0x03, 0x3c, 0x93, 0x43, 0x12, 0xd6, 0xa5, 0xf9, 0x22, 0x37, 0xfc, 0xfa, + 0xaf, 0xf2, 0xfc, 0x81, + ], + [ + 0xee, 0x02, 0xd8, 0x1e, 0xb0, 0x28, 0x38, 0x9f, 0x68, 0x26, 0x61, 0xa9, 0x5b, + 0x7d, 0xc4, 0x47, 0x24, 0x24, 0xd7, 0x9b, + ], + [ + 0xcd, 0x4e, 0xdd, 0x84, 0x5f, 0x65, 0xb5, 0xd5, 0x34, 0xff, 0xaf, 0x55, 0x30, + 0x51, 0xdb, 0x44, 0xfd, 0xf4, 0x07, 0x8d, 0x3a, 0xce, 0xa3, 0xc3, 0xa1, 0x6c, + 0x65, 0x06, 0xd7, 0x79, 0x88, 0xed, + ], + [ + 0xe2, 0xcb, 0xf7, 0xe0, 0xab, 0x29, 0xe8, 0xac, 0x70, 0x73, 0x4a, 0xfb, 0xfb, + 0x87, 0xc7, 0x6b, 0xfa, 0x06, 0x87, 0xba, 0x28, 0x04, 0xd6, 0x77, 0x6f, 0x39, + 0xe4, 0x21, 0x90, 0x7c, 0xf1, 0x28, 0x9b, 0x76, 0x68, 0x5b, 0xdb, 0x66, 0x64, + 0x06, 0x4f, 0x6c, 0x81, 0x45, 0xbc, 0x63, 0xa7, 0x53, + ], + [ + 0x73, 0xed, 0x28, 0x11, 0xa9, 0xb5, 0xd8, 0xc3, 0x9c, 0x9f, 0xe0, 0x1b, 0x32, + 0xb1, 0x43, 0xe6, 0x99, 0x0e, 0x79, 0x56, 0xe8, 0x83, 0x57, 0xd3, 0xcd, 0xad, + 0x14, 0x4f, 0xcd, 0x1b, 0x01, 0x82, 0x47, 0x27, 0x01, 0xee, 0x3d, 0x50, 0x90, + 0x17, 0x93, 0xf3, 0x5e, 0x02, 0x8e, 0x1c, 0xa6, 0xf7, 0xf1, 0xfe, 0x0e, 0x19, + 0x9c, 0x19, 0x45, 0xc1, 0x51, 0xe7, 0x18, 0xaf, 0x6a, 0x80, 0x2b, 0x84, + ] + ), + test_case!( + [ + 0x32, 0xac, 0x3d, 0xbc, 0x99, 0x0d, 0x3d, 0xc2, 0xba, 0xf6, 0xee, 0xcc, 0x78, + 0x0f, 0x64, 0xa2, 0x03, 0x08, 0x08, 0xcd, 0x57, 0x00, 0x19, 0x9f, 0xa1, 0xa9, + 0xf9, 0x0d, 0x67, 0xd0, 0x00, + ], + [ + 0xba, 0x29, 0x75, 0x9d, 0xb2, 0x89, 0xe4, 0x65, 0x20, 0x18, 0xe0, 0x77, 0xf8, + 0x59, 0x94, 0x11, 0xa8, 0x47, 0xbb, 0x2f, + ], + [ + 0xf0, 0x88, 0x03, 0xc7, 0xa1, 0xf5, 0x13, 0x04, 0x3f, 0x01, 0xd1, 0xca, 0x65, + 0x86, 0x98, 0x09, 0xa8, 0xd4, 0xa2, 0x80, 0x12, 0x7a, 0x0c, 0xb6, 0x02, 0xe8, + 0xc9, 0x56, 0x1f, 0xc6, 0xec, 0x7a, + ], + [ + 0xb3, 0x27, 0xc8, 0x0b, 0x23, 0xb0, 0xad, 0xae, 0xea, 0x14, 0xa2, 0xf2, 0x0e, + 0x1b, 0xab, 0xc3, 0xd2, 0xac, 0x56, 0xfe, 0x14, 0xf8, 0xce, 0x73, 0xac, 0x12, + 0xe6, 0x7b, 0xc3, 0x1a, 0x58, 0x19, 0xd0, 0x87, 0x15, 0xa2, 0xc9, 0x9e, 0x3c, + 0x84, 0x7d, 0x50, 0xe9, 0x41, 0x3d, 0x74, 0x1c, 0x13, + ], + [ + 0x2e, 0x36, 0xac, 0xe8, 0x14, 0xd6, 0x9e, 0xf8, 0x04, 0xe0, 0xfb, 0x36, 0x23, + 0xb8, 0xb5, 0x36, 0x29, 0xc3, 0x16, 0x33, 0x8a, 0x3d, 0xa7, 0x33, 0xeb, 0x60, + 0x09, 0xa2, 0x83, 0xf9, 0x69, 0x42, 0xef, 0xd6, 0x77, 0x82, 0x7d, 0xef, 0x45, + 0x87, 0xdd, 0x55, 0x37, 0x21, 0xa2, 0x9f, 0x71, 0xa8, 0xde, 0xcd, 0x07, 0x07, + 0xf3, 0xf0, 0x16, 0xf6, 0x95, 0x25, 0x30, 0x26, 0xa4, 0x73, 0xe3, 0x04, + ] + ), + test_case!( + [ + 0xec, 0x06, 0x20, 0xc1, 0xb7, 0xb7, 0xbb, 0xc8, 0x00, 0x0e, 0x54, 0xb5, 0xbb, + 0x7e, 0x0b, 0xdf, 0xb5, 0x97, 0xf3, 0xa7, 0x43, 0x8e, 0xd0, 0xf0, 0x9a, 0xba, + 0x48, 0x35, 0xa4, 0xa0, 0xf5, 0xee, + ], + [ + 0xf6, 0xd8, 0xcb, 0x20, 0xa3, 0x08, 0x65, 0xdb, 0x4d, 0x27, 0xe7, 0x24, 0xa5, + 0x9c, 0x8d, 0x29, 0xbf, 0xc7, 0x49, 0x4c, + ], + [ + 0x78, 0xf9, 0x5b, 0xec, 0x7a, 0x79, 0x03, 0x12, 0xdd, 0x0d, 0xb8, 0x98, 0xca, + 0xb7, 0x8d, 0xbf, 0x1c, 0x65, 0x69, 0x41, 0xeb, 0x3c, 0xc2, 0x33, 0x84, 0x43, + 0xb0, 0xc0, 0xed, 0x39, 0x50, 0x57, + ], + [ + 0xf7, 0xc9, 0x4b, 0xd8, 0x2d, 0xe8, 0xcf, 0x76, 0x30, 0xd0, 0x87, 0x33, 0xfe, + 0x60, 0x7d, 0x54, 0xee, 0x26, 0xb0, 0xd9, 0x87, 0xbf, 0x5b, 0x73, 0xc6, 0x43, + 0x51, 0xa4, 0x15, 0x02, 0x35, 0x13, 0x6e, 0x4e, 0x8a, 0xa0, 0x48, 0x0c, 0x7f, + 0x17, 0xc3, 0x58, 0xa0, 0xdc, 0xf7, 0x13, 0x59, 0x38, + ], + [ + 0xee, 0xb7, 0xc5, 0x97, 0x81, 0x73, 0x94, 0xfe, 0x5a, 0xdd, 0x0c, 0xde, 0x51, + 0x16, 0xf8, 0x5d, 0x4a, 0x16, 0x46, 0x73, 0x78, 0xbb, 0x1a, 0x8e, 0x42, 0xe7, + 0x1a, 0x74, 0xbf, 0x26, 0xc3, 0x00, 0xc3, 0x62, 0xbd, 0x37, 0xca, 0x16, 0x74, + 0x5f, 0xea, 0x97, 0x55, 0x2c, 0x2f, 0xf5, 0xd2, 0xbe, 0x7c, 0x32, 0x15, 0xdf, + 0xa5, 0x6f, 0xed, 0x38, 0x91, 0x47, 0xf7, 0xaf, 0x17, 0xee, 0x78, 0x44, + ] + ), + test_case!( + [ + 0xd8, 0x3f, 0x48, 0x02, 0x79, 0x3e, 0x53, 0x79, 0xe1, 0x0c, 0x90, 0x2a, 0x86, + 0x76, 0xe3, 0xb8, 0x82, 0xdf, 0x20, 0xd4, 0xd8, 0xf1, 0x21, 0x3f, 0x87, 0xbd, + 0x03, 0xf7, 0x6d, 0xf2, 0x4b, 0x32, 0xee, + ], + [ + 0x0c, 0xb3, 0x00, 0xca, 0x40, 0x5e, 0x61, 0x50, 0xba, 0x43, 0xf9, 0x12, 0x45, + 0xfd, 0x0c, 0x83, 0xe7, 0x74, 0x09, 0x10, + ], + [ + 0x1f, 0x35, 0x61, 0x55, 0xad, 0x41, 0x86, 0x93, 0x39, 0xb9, 0x49, 0x94, 0xcd, + 0xac, 0x3f, 0x16, 0x82, 0xad, 0x00, 0xf5, 0x38, 0x39, 0x29, 0x26, 0x13, 0x2d, + 0x57, 0xa4, 0x90, 0x83, 0x0a, 0x44, + ], + [ + 0x01, 0x70, 0x2c, 0x07, 0x01, 0xfa, 0xa2, 0x73, 0x3f, 0xb2, 0xbf, 0xfa, 0x14, + 0xaf, 0x95, 0x1c, 0xbc, 0x5c, 0x2d, 0xa0, 0x03, 0xc3, 0xd5, 0x6e, 0x42, 0x5e, + 0x41, 0xf2, 0xa2, 0x12, 0x74, 0xc7, 0xa0, 0xa6, 0x60, 0x68, 0x13, 0x42, 0xec, + 0xfc, 0x4f, 0x95, 0x78, 0xca, 0x73, 0x34, 0x88, 0x72, + ], + [ + 0x83, 0x5e, 0xd9, 0x1f, 0xcc, 0x9a, 0x86, 0xa1, 0x4c, 0x44, 0x84, 0xa3, 0x56, + 0x54, 0x52, 0x9e, 0xde, 0x82, 0xf7, 0xc3, 0x9f, 0xd6, 0x78, 0xd3, 0x58, 0xa4, + 0x2a, 0x23, 0x0a, 0xce, 0x36, 0x22, 0xdd, 0x86, 0x46, 0x4c, 0x72, 0x62, 0x2f, + 0x29, 0xe6, 0x2b, 0x2a, 0xbc, 0xa1, 0x61, 0x21, 0x44, 0x95, 0x7e, 0x7a, 0x38, + 0x29, 0x57, 0x93, 0xe4, 0x1f, 0xe1, 0x77, 0x8d, 0x06, 0x65, 0xe5, 0x1f, + ] + ), + test_case!( + [ + 0xf4, 0xeb, 0xb5, 0x70, 0xdc, 0x36, 0xf6, 0x25, 0xa8, 0xe8, 0xae, 0x40, 0x7a, + 0x39, 0xdf, 0x0d, 0xc0, 0xd7, 0xf9, 0x6e, 0x9e, 0x24, 0x97, 0x5f, 0x84, 0x78, + 0xd7, 0x31, 0x18, 0xfa, 0x13, 0xd5, 0x1b, 0x93, + ], + [ + 0x3f, 0xd8, 0xc3, 0x1d, 0x6b, 0x20, 0x2a, 0xdb, 0x3b, 0xac, 0x6b, 0x3a, 0x50, + 0x05, 0x54, 0x7f, 0x1c, 0x8e, 0x3c, 0x2e, + ], + [ + 0x94, 0x20, 0x5d, 0xbf, 0xd0, 0x85, 0x38, 0x75, 0x18, 0x08, 0xb2, 0x2f, 0x33, + 0x3a, 0xbc, 0xca, 0xf1, 0xa9, 0xde, 0x86, 0x9d, 0x4f, 0xa9, 0x8d, 0x2c, 0x60, + 0x0c, 0x8c, 0xa2, 0xa9, 0xce, 0x8b, + ], + [ + 0xcf, 0x28, 0xe1, 0x59, 0xb2, 0xd5, 0xea, 0x81, 0xd6, 0x9f, 0xb1, 0x4a, 0xba, + 0xe3, 0xd4, 0x48, 0x5a, 0x4f, 0x49, 0xdd, 0xdc, 0x14, 0x38, 0x45, 0xab, 0xb2, + 0x9e, 0x2b, 0x41, 0x86, 0x24, 0x77, 0x87, 0xee, 0xa3, 0xfc, 0xab, 0xdb, 0xf3, + 0xea, 0xee, 0x09, 0x53, 0xb6, 0xc3, 0x64, 0x46, 0xba, + ], + [ + 0x02, 0xce, 0xe5, 0x88, 0xb2, 0x09, 0x6d, 0xd5, 0xf5, 0xf4, 0xa4, 0xe4, 0x7a, + 0x48, 0x20, 0xa3, 0xde, 0x81, 0x6e, 0x8d, 0xa5, 0x1e, 0xf0, 0x6d, 0x0d, 0x1c, + 0x0b, 0x0d, 0x74, 0xca, 0x44, 0x29, 0xc7, 0xf2, 0x39, 0x8c, 0x83, 0xad, 0xb3, + 0x15, 0x6a, 0xdf, 0x49, 0xc2, 0xfa, 0x08, 0x10, 0x8e, 0x38, 0xd2, 0xce, 0x32, + 0xae, 0x67, 0xc0, 0xa2, 0xfa, 0x08, 0xd4, 0xd1, 0xb7, 0x36, 0xbd, 0x96, + ] + ), + test_case!( + [ + 0x90, 0x10, 0x96, 0xca, 0x77, 0x56, 0x7d, 0x1e, 0xa2, 0x93, 0xe5, 0x15, 0x7d, + 0xcd, 0x10, 0x0b, 0x03, 0x9c, 0x8c, 0x01, 0xbc, 0xde, 0xbf, 0x80, 0xc5, 0xe7, + 0xf3, 0xb2, 0x04, 0x2d, 0x6d, 0x26, 0x70, 0x28, 0xdf, + ], + [ + 0xec, 0x2b, 0x0c, 0x5c, 0xfc, 0xe2, 0xb1, 0xc3, 0xf8, 0x03, 0x3f, 0x37, 0x4d, + 0x88, 0x48, 0xa9, 0xe0, 0xa8, 0x22, 0x7c, + ], + [ + 0x28, 0x82, 0x80, 0x32, 0x60, 0xc9, 0x39, 0xf8, 0x28, 0x43, 0x41, 0xa1, 0xd8, + 0x3a, 0x5e, 0x2a, 0x60, 0x4d, 0x8a, 0xd1, 0x7a, 0x26, 0x5c, 0x60, 0x24, 0xd9, + 0x84, 0x14, 0xf5, 0x00, 0x55, 0xe3, + ], + [ + 0x5e, 0x3a, 0xab, 0x06, 0x1f, 0x57, 0x34, 0x75, 0xa9, 0x0d, 0x07, 0x26, 0x5c, + 0xdc, 0x55, 0xdb, 0x75, 0x1f, 0x5e, 0x20, 0x00, 0x2b, 0x9e, 0x13, 0x35, 0x91, + 0x58, 0x12, 0xbf, 0x9b, 0xea, 0x77, 0x41, 0x82, 0xd2, 0x1b, 0x69, 0xec, 0xce, + 0xb0, 0xdc, 0x83, 0x5b, 0x66, 0x0a, 0x32, 0xbd, 0xda, + ], + [ + 0x20, 0xac, 0x92, 0x38, 0xb4, 0x52, 0xe2, 0x62, 0xf9, 0x2f, 0xd3, 0x65, 0x6e, + 0xe2, 0x33, 0x12, 0xf2, 0x2e, 0x09, 0xc7, 0x66, 0x3a, 0xa2, 0xbf, 0x89, 0x21, + 0x88, 0x50, 0x8a, 0xf1, 0xaf, 0xd8, 0x91, 0x00, 0x95, 0x07, 0x0e, 0x8a, 0x5e, + 0xd7, 0xaa, 0x7c, 0x04, 0x2f, 0x69, 0x51, 0x83, 0x97, 0xa6, 0xb3, 0x56, 0xcf, + 0x1e, 0x5c, 0xe3, 0xc6, 0x0e, 0x06, 0xab, 0x8e, 0x0b, 0xcb, 0xb0, 0x0e, + ] + ), + test_case!( + [ + 0xda, 0x0b, 0xa3, 0x35, 0x62, 0x5e, 0x26, 0x80, 0x1a, 0x5f, 0xb9, 0xa8, 0x5e, + 0xb9, 0xcd, 0x61, 0x3e, 0x67, 0xbc, 0x21, 0xb9, 0xf0, 0x51, 0x5a, 0x03, 0x22, + 0x56, 0xd5, 0x6c, 0x04, 0xd0, 0x1b, 0xfb, 0xf0, 0x34, 0x95, + ], + [ + 0xa2, 0xaf, 0x27, 0x7c, 0x93, 0x4c, 0x57, 0xaa, 0x09, 0xff, 0xb4, 0xdb, 0x21, + 0x22, 0x7a, 0xe8, 0x03, 0x41, 0x6e, 0x30, + ], + [ + 0x72, 0xd7, 0xa9, 0xaf, 0xde, 0xab, 0x9a, 0x4d, 0xd3, 0xc4, 0x1e, 0x6c, 0xbd, + 0xd3, 0x9a, 0xa4, 0x85, 0x47, 0xc6, 0xfa, 0xac, 0x7b, 0x70, 0x21, 0x53, 0xa4, + 0xa1, 0x89, 0xe6, 0x11, 0x8a, 0x04, + ], + [ + 0x6c, 0x19, 0xd6, 0x8c, 0x72, 0xb4, 0x6d, 0x1b, 0x2d, 0x13, 0x16, 0x7a, 0x84, + 0x5b, 0x2f, 0x41, 0x24, 0xcd, 0x87, 0x0e, 0xab, 0x61, 0xfb, 0x0c, 0x37, 0xa2, + 0x5b, 0x9b, 0x6c, 0x75, 0x92, 0xfb, 0xcf, 0x51, 0xbf, 0xda, 0x9d, 0x3d, 0xce, + 0x06, 0xd9, 0xaf, 0x33, 0xba, 0x87, 0x93, 0x5b, 0x9b, + ], + [ + 0x49, 0xbd, 0x64, 0x1d, 0x17, 0xc2, 0xa5, 0x03, 0xfe, 0xf7, 0xda, 0xf0, 0x47, + 0x99, 0xcc, 0x35, 0x67, 0xe3, 0x36, 0x26, 0x8f, 0xde, 0x21, 0x45, 0xf4, 0x4d, + 0xa0, 0xd1, 0x44, 0xae, 0x49, 0xd6, 0x41, 0x28, 0xb4, 0xef, 0x8c, 0x2a, 0xd1, + 0xfe, 0x1d, 0x02, 0x63, 0x8c, 0x82, 0x3c, 0xda, 0x89, 0x38, 0x4a, 0xbc, 0xdc, + 0x1b, 0xe2, 0x97, 0xed, 0x36, 0x2c, 0x0c, 0x31, 0x6a, 0xaa, 0x6e, 0x4e, + ] + ), + test_case!( + [ + 0x67, 0x67, 0xf6, 0xd1, 0xc8, 0xec, 0xe7, 0x31, 0xdb, 0x00, 0xff, 0x8a, 0xdf, + 0x34, 0x8e, 0xc4, 0xa5, 0x79, 0x86, 0x1d, 0xa8, 0x88, 0x7e, 0xcb, 0xb0, 0xca, + 0x6b, 0x04, 0x72, 0xfe, 0xe6, 0xb2, 0x5a, 0x66, 0x29, 0xcc, 0x38, + ], + [ + 0x37, 0x65, 0xe4, 0xf5, 0xe2, 0x05, 0x97, 0x40, 0x04, 0xa9, 0x52, 0x50, 0x2e, + 0x74, 0xf6, 0xec, 0xd5, 0x65, 0x45, 0x2d, + ], + [ + 0x65, 0x62, 0x8e, 0x28, 0x24, 0x40, 0xbe, 0x6c, 0xa7, 0x24, 0x6c, 0xf2, 0x87, + 0x2b, 0xeb, 0x35, 0x60, 0xc3, 0x7b, 0x68, 0x43, 0x19, 0x47, 0xdf, 0xe5, 0xb4, + 0x15, 0xa6, 0x07, 0xd0, 0xd6, 0x65, + ], + [ + 0x73, 0x19, 0xc6, 0x1a, 0x87, 0xf9, 0x65, 0xb6, 0x43, 0xcc, 0x42, 0x61, 0xf8, + 0x8c, 0x65, 0x40, 0x9f, 0xb5, 0xa7, 0x09, 0xd6, 0x74, 0xaa, 0x74, 0x91, 0x28, + 0x6b, 0xbf, 0xbb, 0x3a, 0x7e, 0x8e, 0xef, 0x84, 0x45, 0xb7, 0x36, 0x59, 0xd8, + 0x45, 0xc5, 0x60, 0x3e, 0x11, 0x30, 0xbb, 0x29, 0x74, + ], + [ + 0x21, 0xfa, 0x4c, 0xfb, 0xf9, 0xc9, 0xf5, 0x63, 0xbe, 0x66, 0x2b, 0xf9, 0x70, + 0x13, 0x2e, 0x31, 0x2f, 0x9c, 0x20, 0x38, 0xd7, 0x82, 0xb7, 0xc0, 0xb0, 0x98, + 0xd3, 0xf2, 0x45, 0x7f, 0x35, 0x7e, 0xaf, 0x40, 0x7b, 0x40, 0x38, 0xb3, 0xda, + 0x8e, 0x94, 0x70, 0xa0, 0xf0, 0x4e, 0x69, 0x15, 0x04, 0x9a, 0x15, 0x31, 0x00, + 0x09, 0x83, 0x35, 0x48, 0x68, 0x58, 0xdd, 0xb8, 0x49, 0x90, 0x60, 0xa9, + ] + ), + test_case!( + [ + 0x9e, 0xec, 0x21, 0x11, 0x1f, 0x1c, 0xff, 0xee, 0xfd, 0x85, 0xcb, 0x87, 0x20, + 0x33, 0x54, 0xdb, 0x64, 0xa7, 0x50, 0xbe, 0xb4, 0xad, 0x25, 0x46, 0x5f, 0x75, + 0x2e, 0x3e, 0x52, 0xac, 0xc4, 0x48, 0xaa, 0x71, 0x99, 0x75, 0x6c, 0xa1, + ], + [ + 0x9c, 0x45, 0x5c, 0x9f, 0x54, 0xd2, 0xad, 0x2e, 0x79, 0x8a, 0x5a, 0x6c, 0x89, + 0xe9, 0x24, 0x34, 0x20, 0x35, 0xb3, 0x18, + ], + [ + 0x95, 0x3a, 0x67, 0x6a, 0x83, 0xf6, 0x02, 0x98, 0xea, 0x33, 0xae, 0x32, 0xd1, + 0xdb, 0x5d, 0x28, 0x83, 0xb1, 0x68, 0x7e, 0xbe, 0xd2, 0xc0, 0xe3, 0x0e, 0xd1, + 0xe0, 0x6e, 0x2e, 0xb3, 0xfa, 0xe3, + ], + [ + 0x65, 0x12, 0x95, 0x58, 0xfa, 0xd4, 0x43, 0x56, 0x05, 0xd6, 0x92, 0xe2, 0xdc, + 0xe3, 0x40, 0x05, 0x85, 0xdc, 0x46, 0xd4, 0xef, 0xca, 0x46, 0x8e, 0x24, 0x7e, + 0x7b, 0xd8, 0xb2, 0x11, 0xe5, 0xef, 0x68, 0xf9, 0xd1, 0xec, 0x10, 0xb7, 0x06, + 0x04, 0x9c, 0xeb, 0x04, 0x5b, 0xf1, 0x26, 0x1a, 0x3d, + ], + [ + 0x98, 0xb8, 0x27, 0x6c, 0xd0, 0x18, 0x6b, 0xa2, 0x4c, 0xa1, 0x86, 0x68, 0x76, + 0x8e, 0x12, 0xdc, 0xa8, 0xc0, 0xbe, 0x7f, 0xd1, 0xcf, 0xb1, 0x73, 0xb3, 0x55, + 0xa9, 0x4b, 0xff, 0x16, 0x32, 0x83, 0x7e, 0x29, 0xc7, 0x01, 0xe2, 0x6f, 0x64, + 0x1b, 0x53, 0x85, 0x8d, 0x45, 0x95, 0x1b, 0x05, 0xb9, 0xed, 0xf7, 0xc3, 0x65, + 0xa5, 0xb2, 0xbb, 0x39, 0xcc, 0xdc, 0x45, 0xed, 0x62, 0x83, 0x45, 0xbf, + ] + ), + test_case!( + [ + 0xe4, 0xa1, 0xf7, 0xe6, 0xe1, 0xcf, 0xda, 0xdb, 0x42, 0xad, 0xfc, 0x75, 0x8f, + 0x4b, 0x6e, 0x37, 0x56, 0xa6, 0x13, 0xba, 0xc1, 0xcd, 0x0a, 0xd4, 0x67, 0xa3, + 0xde, 0xdd, 0xab, 0x94, 0x73, 0x08, 0xb0, 0xcb, 0xf4, 0xc7, 0x3d, 0x4c, 0x71, + ], + [ + 0x86, 0x00, 0x23, 0xf1, 0x78, 0x8c, 0x19, 0x44, 0xe3, 0x72, 0x8a, 0x25, 0xb8, + 0x74, 0x09, 0x2b, 0x5f, 0x83, 0x31, 0x69, + ], + [ + 0xd8, 0x29, 0x11, 0xa6, 0x09, 0x06, 0xf5, 0x86, 0xa9, 0xed, 0x82, 0x18, 0xbe, + 0xe2, 0xdb, 0x59, 0x3b, 0x77, 0x33, 0xcf, 0x47, 0x77, 0x3b, 0x96, 0x83, 0xdb, + 0xb2, 0x74, 0x68, 0xed, 0x1e, 0x4f, + ], + [ + 0xa4, 0x7e, 0x3b, 0xb5, 0x55, 0xff, 0xb7, 0x1a, 0xaa, 0xf1, 0xa7, 0x7b, 0x82, + 0xa8, 0x09, 0x19, 0xd7, 0xb8, 0xa6, 0x7e, 0x64, 0x37, 0x72, 0x87, 0x52, 0x61, + 0x0c, 0x5c, 0xd2, 0x35, 0x05, 0x69, 0x04, 0xd8, 0x7f, 0x92, 0x4a, 0x59, 0x1d, + 0x92, 0x15, 0x39, 0xee, 0x4a, 0x82, 0x25, 0x4f, 0x97, + ], + [ + 0x67, 0x44, 0x63, 0xe9, 0x9d, 0xd6, 0x79, 0x3d, 0xa5, 0x4a, 0xf4, 0xfb, 0xd8, + 0x53, 0x80, 0xec, 0x16, 0x0e, 0x6a, 0x9c, 0x6b, 0x20, 0x96, 0x6e, 0x15, 0xca, + 0x21, 0xd3, 0x0b, 0x60, 0x37, 0x7b, 0x7e, 0xc5, 0xf3, 0x8a, 0xba, 0xfa, 0x4e, + 0x7f, 0x89, 0x69, 0xcc, 0x37, 0x03, 0xf3, 0xe9, 0x78, 0x76, 0x78, 0xb1, 0xd7, + 0xe5, 0x2c, 0xd6, 0x60, 0x33, 0xf2, 0x99, 0xa8, 0x3a, 0xf4, 0xc7, 0x65, + ] + ), + test_case!( + [ + 0x7e, 0xf0, 0xfb, 0x04, 0x57, 0x1d, 0x94, 0x0e, 0x5f, 0xea, 0x9b, 0x25, 0x0c, + 0x27, 0x5d, 0xcd, 0x9f, 0x7a, 0x27, 0x89, 0x6d, 0x9b, 0xb9, 0x7e, 0xb4, 0x88, + 0x04, 0x85, 0x73, 0xbb, 0x94, 0xea, 0x5f, 0x3a, 0xeb, 0x3b, 0x52, 0xa4, 0x6f, + 0x91, + ], + [ + 0x3a, 0x86, 0xca, 0x97, 0x7e, 0x3e, 0x9f, 0x67, 0x31, 0xa1, 0x1b, 0x74, 0x39, + 0x2c, 0x4e, 0x25, 0xce, 0x74, 0x1a, 0xd5, + ], + [ + 0x89, 0x19, 0xc3, 0x23, 0xa5, 0x16, 0xa0, 0x6d, 0xf3, 0xc7, 0x7d, 0x5f, 0xdc, + 0x13, 0xfc, 0x9c, 0xdc, 0xc8, 0x69, 0x47, 0x34, 0xf7, 0x9f, 0x5e, 0x4b, 0x19, + 0xcb, 0xd7, 0xa5, 0x2f, 0x71, 0xc4, + ], + [ + 0x40, 0x2f, 0xb5, 0x28, 0x03, 0xd5, 0x57, 0xba, 0xa3, 0x4b, 0x13, 0x5f, 0x1e, + 0x9e, 0xa7, 0x06, 0x2d, 0x42, 0x6f, 0x54, 0x2b, 0x84, 0x4d, 0xfd, 0x6e, 0xdd, + 0x4b, 0xc5, 0x8d, 0xde, 0x8a, 0x47, 0x82, 0x73, 0x01, 0x74, 0x9c, 0x2d, 0xf1, + 0x4f, 0x20, 0xc7, 0xe7, 0x23, 0xd1, 0xc7, 0x86, 0x37, + ], + [ + 0x76, 0xe2, 0x3a, 0x8c, 0x23, 0x57, 0x6a, 0x6d, 0x77, 0xc1, 0xef, 0x5c, 0x29, + 0xa5, 0xe3, 0xeb, 0x55, 0x60, 0xf8, 0x19, 0x60, 0x86, 0x9d, 0xa0, 0xdb, 0x03, + 0x55, 0xf8, 0x78, 0x9f, 0x93, 0x9a, 0x1a, 0x1f, 0xcb, 0xde, 0x8a, 0xee, 0x3d, + 0x79, 0x60, 0x0f, 0x16, 0xba, 0xdb, 0xd0, 0x5e, 0x01, 0xcd, 0x49, 0xe0, 0x46, + 0x7c, 0x72, 0x75, 0xb2, 0x11, 0x1c, 0x73, 0x24, 0xe3, 0x72, 0x89, 0x64, + ] + ), + test_case!( + [ + 0xda, 0x47, 0x7c, 0x20, 0x0c, 0x53, 0x39, 0x7a, 0x41, 0xe9, 0x04, 0xd6, 0xe2, + 0x37, 0x49, 0x47, 0xec, 0x22, 0x1a, 0x11, 0x4c, 0x5b, 0x42, 0x6f, 0xa4, 0x05, + 0x65, 0xfe, 0xb6, 0x91, 0x57, 0xc2, 0x9b, 0x74, 0x32, 0xb3, 0x8e, 0x97, 0x27, + 0xb5, 0x24, + ], + [ + 0x0a, 0x5c, 0x93, 0xef, 0x9c, 0x3e, 0xe6, 0xf3, 0xa2, 0xbf, 0xf9, 0x2c, 0x20, + 0x86, 0x79, 0xbe, 0x72, 0xe3, 0x09, 0x55, + ], + [ + 0xd6, 0xf2, 0x02, 0x92, 0xf9, 0x7c, 0x69, 0x4b, 0xd3, 0x40, 0xc5, 0xba, 0x7a, + 0xe5, 0x14, 0x07, 0xae, 0xcc, 0xc6, 0x4f, 0xbe, 0x46, 0x0a, 0x40, 0x54, 0x2b, + 0x8d, 0x35, 0x8e, 0xf9, 0x29, 0x32, + ], + [ + 0x49, 0x2e, 0x95, 0x4a, 0xa9, 0x0c, 0x08, 0x94, 0x0e, 0x1e, 0xeb, 0xa4, 0x66, + 0xc2, 0xed, 0xa5, 0x97, 0xc3, 0x51, 0xdb, 0xe6, 0xe4, 0xa5, 0xad, 0x7a, 0xfd, + 0x7d, 0x6f, 0x42, 0xc3, 0xb4, 0x88, 0x5b, 0xef, 0xdc, 0xf0, 0x33, 0x0b, 0x33, + 0x45, 0xe8, 0xfc, 0x40, 0x41, 0x9f, 0x74, 0x45, 0x42, + ], + [ + 0x31, 0x0f, 0x89, 0xbf, 0xf5, 0x8a, 0x25, 0xfb, 0x64, 0xd2, 0x79, 0xba, 0x07, + 0xab, 0xd2, 0x58, 0x61, 0x8c, 0x02, 0x10, 0x74, 0xed, 0xdb, 0x6e, 0x7f, 0xbe, + 0x64, 0x95, 0xcd, 0x67, 0xdd, 0x10, 0x32, 0x9a, 0x97, 0x19, 0xa6, 0xb5, 0x53, + 0x6c, 0x07, 0xe5, 0xcd, 0x67, 0xfe, 0xbe, 0x68, 0x7c, 0xe8, 0xe3, 0x9d, 0x78, + 0x3e, 0x1b, 0x26, 0x5e, 0x64, 0xb2, 0x2c, 0x60, 0x5a, 0xe6, 0x13, 0xc6, + ] + ), + test_case!( + [ + 0xc9, 0x10, 0x25, 0x7f, 0xd5, 0x52, 0x42, 0x78, 0x75, 0xae, 0x3a, 0xcb, 0xc4, + 0x51, 0xd1, 0x67, 0x8a, 0xba, 0x32, 0xc5, 0xab, 0x0c, 0xce, 0x7a, 0xef, 0x0b, + 0xfa, 0xb9, 0x39, 0xbe, 0x72, 0xb5, 0x5c, 0x05, 0x1a, 0xdd, 0xf1, 0x91, 0x96, + 0x7e, 0x40, 0xe8, + ], + [ + 0x07, 0x78, 0x50, 0x5c, 0x66, 0xe0, 0x14, 0x8c, 0x43, 0xc0, 0x89, 0x30, 0xaf, + 0xff, 0x85, 0x63, 0x7c, 0x68, 0xcf, 0x4c, + ], + [ + 0x5a, 0x68, 0xee, 0xb1, 0xd5, 0x4a, 0x7f, 0xca, 0x24, 0x0a, 0x0b, 0xc6, 0x98, + 0xe0, 0xce, 0x6b, 0xd9, 0x3d, 0xfc, 0x81, 0xe4, 0x41, 0xf8, 0xef, 0x31, 0x57, + 0x15, 0x06, 0x15, 0xb6, 0x05, 0x7f, + ], + [ + 0x4a, 0xe7, 0x77, 0xbc, 0x8f, 0x64, 0xe7, 0x31, 0x86, 0xe2, 0x38, 0x39, 0xb8, + 0x97, 0x01, 0x9e, 0x2a, 0x4f, 0x2a, 0x05, 0x56, 0x97, 0x68, 0x14, 0x5c, 0x3b, + 0x91, 0xf5, 0x1d, 0xf3, 0x20, 0x3a, 0xb4, 0x83, 0x10, 0xf6, 0x0b, 0xc9, 0x7b, + 0xe8, 0x36, 0x36, 0x64, 0x3a, 0xc7, 0xa2, 0xe8, 0x37, + ], + [ + 0x11, 0x77, 0xf8, 0xd5, 0x62, 0x70, 0x46, 0xee, 0xa6, 0x6a, 0xd8, 0xfe, 0xe1, + 0x4b, 0xf6, 0xac, 0xca, 0xf4, 0x9e, 0xfb, 0x70, 0xbd, 0x78, 0x33, 0x99, 0x56, + 0x6e, 0xcd, 0x7a, 0x23, 0x0f, 0x44, 0xea, 0x47, 0x8d, 0xbc, 0xcb, 0x53, 0x91, + 0xdf, 0x06, 0x18, 0x64, 0x3c, 0x1b, 0xf5, 0x94, 0xd3, 0xeb, 0xa8, 0xdf, 0xf7, + 0x4e, 0x70, 0x98, 0x52, 0x2b, 0xa0, 0xa7, 0x9f, 0x53, 0x1e, 0x3c, 0xd5, + ] + ), + test_case!( + [ + 0x89, 0x6b, 0xb1, 0xe2, 0x58, 0x28, 0x8e, 0xa0, 0x54, 0x40, 0x7f, 0x11, 0x56, + 0x59, 0xce, 0x03, 0x0f, 0x62, 0xf5, 0x17, 0xe9, 0xce, 0x2b, 0xe1, 0x2f, 0xaa, + 0x89, 0x1f, 0xaf, 0x34, 0xda, 0x8a, 0xed, 0x73, 0x28, 0xf1, 0x25, 0x48, 0x34, + 0xac, 0xd0, 0xb3, 0x2a, + ], + [ + 0x1a, 0x93, 0x96, 0xdf, 0xb9, 0x5d, 0x50, 0x20, 0x1a, 0x02, 0xfc, 0x45, 0xaf, + 0x2d, 0x23, 0xe4, 0xf3, 0x4b, 0xdc, 0xb3, + ], + [ + 0x9d, 0x36, 0x9c, 0x71, 0xca, 0x90, 0xb5, 0x34, 0xbe, 0x9c, 0x93, 0x6b, 0x51, + 0xeb, 0x30, 0x80, 0xf4, 0xfd, 0x95, 0x8f, 0x8b, 0xdf, 0x8e, 0x46, 0x6a, 0xa4, + 0xec, 0xbe, 0x6b, 0x1d, 0x2c, 0xe2, + ], + [ + 0x97, 0x04, 0x07, 0xec, 0x33, 0xbb, 0x69, 0x40, 0xd7, 0x55, 0xca, 0x73, 0x94, + 0x7e, 0x0a, 0x0f, 0x84, 0x17, 0x84, 0x22, 0x9b, 0x6a, 0xab, 0xa0, 0x8b, 0x81, + 0xb4, 0x08, 0x86, 0x5e, 0xb1, 0xc7, 0xea, 0x87, 0x87, 0x27, 0xd0, 0x90, 0x05, + 0xf1, 0xf4, 0x07, 0x06, 0xae, 0x32, 0xeb, 0x36, 0x9e, + ], + [ + 0x41, 0x07, 0xf1, 0x39, 0x65, 0x07, 0xa1, 0x7b, 0x45, 0xe6, 0x41, 0x4f, 0x21, + 0xe1, 0x0f, 0x6f, 0xc3, 0x40, 0x6d, 0xc5, 0xaa, 0xca, 0xe6, 0xeb, 0x45, 0x15, + 0xf2, 0x91, 0xc6, 0x68, 0x76, 0x57, 0x73, 0x16, 0x8b, 0x1a, 0x9c, 0x4f, 0x7d, + 0xf5, 0x64, 0xab, 0x7a, 0x09, 0x46, 0x96, 0x75, 0x8c, 0xf7, 0x8a, 0x14, 0x35, + 0x42, 0x80, 0xc0, 0xf6, 0x78, 0xe0, 0xc3, 0xcc, 0xfa, 0xd9, 0x28, 0x8b, + ] + ), + test_case!( + [ + 0x6c, 0x8d, 0xe8, 0x8f, 0x42, 0x6b, 0x1a, 0xf8, 0xde, 0x5f, 0xf2, 0x40, 0xdd, + 0x3b, 0x39, 0x85, 0x41, 0x9c, 0xf5, 0xa8, 0x91, 0x94, 0xde, 0x20, 0x62, 0x80, + 0xb9, 0x82, 0xbe, 0x02, 0x4f, 0xdf, 0x2a, 0x32, 0xca, 0x59, 0xbb, 0xf7, 0xbf, + 0x2f, 0xa1, 0x37, 0x2e, 0x18, + ], + [ + 0x89, 0x59, 0x0b, 0x53, 0x02, 0x3e, 0x70, 0xe1, 0xff, 0x64, 0x57, 0x97, 0x2b, + 0x1e, 0xf4, 0xfb, 0x54, 0xac, 0x01, 0x66, + ], + [ + 0xb7, 0x66, 0x23, 0xb4, 0xe4, 0x86, 0xf5, 0x19, 0x62, 0xae, 0xb2, 0x19, 0x9c, + 0xe3, 0x79, 0x79, 0x83, 0x86, 0x4e, 0xff, 0xd7, 0x0e, 0x6e, 0x2b, 0x5f, 0x6d, + 0xc6, 0x3c, 0xb5, 0xa8, 0x12, 0x95, + ], + [ + 0x26, 0x96, 0xde, 0x5e, 0xc8, 0x77, 0x52, 0xb7, 0xb4, 0x9a, 0x6a, 0x16, 0x67, + 0xfe, 0x91, 0xd6, 0x4b, 0x55, 0xbf, 0xc4, 0x5c, 0x5f, 0xc2, 0x47, 0xac, 0xb1, + 0x4d, 0x17, 0xee, 0x32, 0xc1, 0x75, 0xa8, 0x9c, 0x79, 0x6e, 0x58, 0x66, 0xcb, + 0xe7, 0x6c, 0xdc, 0x1c, 0xc9, 0xc7, 0xd7, 0x42, 0xdd, + ], + [ + 0x0b, 0x0f, 0x2d, 0x9d, 0x8c, 0x7f, 0x42, 0x2e, 0x24, 0x3b, 0xc6, 0x3a, 0x9a, + 0xf1, 0x56, 0x93, 0x62, 0x03, 0xe1, 0xe2, 0xf4, 0xc4, 0xed, 0xa9, 0x48, 0x79, + 0x5d, 0xd2, 0xa2, 0xe5, 0x6f, 0xe1, 0xa2, 0x68, 0xa3, 0xfa, 0x95, 0x52, 0x5b, + 0x0a, 0xbd, 0x6d, 0x30, 0xf9, 0x61, 0x72, 0x50, 0xf6, 0x73, 0xa8, 0xd1, 0x0a, + 0xd4, 0x41, 0xc9, 0x0d, 0x7e, 0xc1, 0x45, 0x9e, 0x50, 0x97, 0x20, 0x3d, + ] + ), + test_case!( + [ + 0x11, 0x94, 0xd3, 0x97, 0x1c, 0x7d, 0x20, 0xe2, 0xcc, 0x2f, 0x29, 0xa7, 0x96, + 0x14, 0x0f, 0xd9, 0xd3, 0x3f, 0x1b, 0xf2, 0x43, 0x46, 0x51, 0xec, 0x65, 0x53, + 0xf5, 0xc7, 0xa3, 0xc9, 0x65, 0x2e, 0x44, 0x46, 0x2a, 0x54, 0xa2, 0xaa, 0x22, + 0x5d, 0xc4, 0xe2, 0x15, 0x03, 0xc9, + ], + [ + 0xbf, 0x36, 0xd5, 0xd7, 0xbb, 0xfa, 0x57, 0x5e, 0x59, 0x92, 0x4a, 0x9e, 0xc3, + 0x66, 0xc2, 0xa1, 0xea, 0xb5, 0xdb, 0x9a, + ], + [ + 0x3f, 0x54, 0x1f, 0xba, 0x9b, 0xbd, 0x60, 0xae, 0x9c, 0xe4, 0x60, 0x93, 0x4d, + 0xc6, 0x32, 0x71, 0x90, 0x9c, 0x03, 0x4e, 0x89, 0x29, 0x17, 0x5b, 0x07, 0xae, + 0x21, 0xda, 0xda, 0x59, 0x9f, 0x63, + ], + [ + 0x73, 0x16, 0xda, 0xea, 0x04, 0x65, 0xdc, 0xc8, 0xc5, 0x19, 0x96, 0xa7, 0xb4, + 0xad, 0xb5, 0x31, 0x4f, 0xd3, 0x37, 0x23, 0xe8, 0x33, 0x19, 0x1e, 0x33, 0x3c, + 0xaf, 0xe7, 0x39, 0x4c, 0x7b, 0x4a, 0x0c, 0x4c, 0xc6, 0x91, 0x10, 0xc3, 0x2c, + 0xba, 0xbd, 0x1d, 0x83, 0x7f, 0x0b, 0xc8, 0x20, 0xd4, + ], + [ + 0x9a, 0xd8, 0x8d, 0xfa, 0x8a, 0x56, 0x0e, 0x06, 0xa6, 0x8d, 0xa2, 0xb5, 0xb4, + 0x6a, 0xdd, 0x9b, 0xe8, 0x48, 0x61, 0x33, 0xfe, 0x99, 0x56, 0x8a, 0xd4, 0x5f, + 0x9c, 0xc1, 0xda, 0xd6, 0xdb, 0xab, 0xbb, 0x5b, 0x64, 0xba, 0x09, 0xdf, 0x9c, + 0x1e, 0xb6, 0x8c, 0xfd, 0x75, 0x6e, 0xc8, 0x5d, 0x44, 0xcd, 0xc7, 0x9d, 0x3f, + 0x28, 0xfe, 0x8b, 0x64, 0x6c, 0x32, 0xcd, 0x89, 0x0e, 0x2a, 0x4e, 0xd1, + ] + ), + test_case!( + [ + 0x2c, 0xca, 0xd2, 0x8f, 0xf9, 0xc3, 0x0f, 0xbf, 0x06, 0x1b, 0xb0, 0x7a, 0x15, + 0x6e, 0x2b, 0x8e, 0x36, 0x86, 0xf5, 0x00, 0xc4, 0x5e, 0x49, 0x7f, 0x8b, 0xbb, + 0x92, 0xad, 0x0d, 0xce, 0x7f, 0x71, 0x0c, 0x4c, 0xdf, 0x4d, 0x72, 0x32, 0x57, + 0x22, 0xe2, 0x02, 0x05, 0x25, 0x01, 0x26, + ], + [ + 0x2a, 0xf3, 0x37, 0xb6, 0xaf, 0x81, 0x5a, 0xd6, 0x4e, 0x95, 0xcb, 0x6f, 0xd7, + 0x57, 0x8a, 0x54, 0xdb, 0x2d, 0x84, 0xb5, + ], + [ + 0xbf, 0x7e, 0x37, 0x30, 0x80, 0xf1, 0xe3, 0x57, 0x33, 0xa7, 0x1b, 0x55, 0x17, + 0x2b, 0xa4, 0x66, 0x4c, 0xa8, 0x14, 0x88, 0xc4, 0xdf, 0x10, 0x01, 0x32, 0x3b, + 0x65, 0xb6, 0xbc, 0x14, 0x94, 0x9d, + ], + [ + 0x4b, 0xe9, 0x0b, 0x3e, 0xd8, 0x8f, 0x84, 0xb7, 0xeb, 0x31, 0x8e, 0x2c, 0x85, + 0x83, 0xab, 0x2a, 0x61, 0x0b, 0x00, 0x32, 0x53, 0x69, 0xf5, 0x0a, 0xad, 0x11, + 0x9f, 0x24, 0x14, 0x2f, 0x56, 0x45, 0x5d, 0x76, 0x95, 0xf5, 0x03, 0x49, 0xa6, + 0x42, 0x25, 0xae, 0x08, 0xa7, 0xf4, 0x7c, 0x0d, 0xc9, + ], + [ + 0xbe, 0xbc, 0x4b, 0xb0, 0x44, 0x1a, 0x50, 0x64, 0xce, 0x36, 0x78, 0x25, 0xe1, + 0x90, 0x6f, 0xc1, 0xc8, 0xbf, 0xd9, 0xe2, 0x66, 0x69, 0x90, 0xd5, 0xd7, 0x0b, + 0x87, 0x10, 0xe5, 0xa7, 0x90, 0x93, 0xde, 0x67, 0xc5, 0x94, 0x80, 0x19, 0xd8, + 0xb7, 0xf9, 0x48, 0x9a, 0xeb, 0x58, 0xe5, 0x2e, 0xca, 0xe1, 0xe8, 0x1f, 0x11, + 0x1c, 0x14, 0xf5, 0xda, 0x3c, 0xc2, 0x32, 0x28, 0x7e, 0x87, 0x69, 0xca, + ] + ), + test_case!( + [ + 0xfb, 0x71, 0x78, 0x65, 0x7e, 0x2a, 0x03, 0x55, 0x0d, 0x2d, 0x22, 0x18, 0x65, + 0xd2, 0x8e, 0xae, 0xa0, 0xb9, 0x05, 0x44, 0xc8, 0x68, 0x10, 0x6b, 0xaa, 0xa6, + 0x7e, 0x20, 0xb8, 0x3e, 0xff, 0x2d, 0x99, 0xf8, 0x4e, 0x9b, 0x8f, 0xdc, 0x75, + 0x27, 0xde, 0x44, 0xae, 0x36, 0x33, 0x3c, 0x13, + ], + [ + 0x47, 0x2a, 0x47, 0xdc, 0xda, 0xa3, 0xda, 0xb9, 0x64, 0x88, 0xad, 0x1d, 0xca, + 0x6e, 0x3b, 0x52, 0x63, 0x32, 0x0d, 0x86, + ], + [ + 0x0c, 0xcb, 0x96, 0x36, 0x0a, 0xbe, 0xcc, 0x07, 0xf4, 0x1c, 0xf9, 0x30, 0x05, + 0x07, 0x00, 0x0f, 0x6a, 0xb8, 0x94, 0xbd, 0xa9, 0x20, 0x85, 0x97, 0x55, 0x6b, + 0x26, 0x35, 0x19, 0x40, 0xe6, 0xdb, + ], + [ + 0x5e, 0x0f, 0xcc, 0x43, 0x58, 0x47, 0x50, 0x4a, 0x2d, 0xc0, 0x68, 0x7b, 0x8b, + 0xf6, 0xd5, 0x0a, 0x87, 0x17, 0x19, 0x6b, 0x45, 0xa6, 0xe1, 0xb6, 0xe9, 0x6c, + 0x92, 0x91, 0xc3, 0x8e, 0xa6, 0xdd, 0x55, 0xd3, 0x77, 0x1b, 0x21, 0x1d, 0x93, + 0xb8, 0xe8, 0x5b, 0x94, 0x7c, 0x49, 0x81, 0x66, 0x9d, + ], + [ + 0xea, 0x93, 0xf2, 0x02, 0xbc, 0xf3, 0x54, 0x76, 0xc1, 0xd9, 0xdb, 0x4d, 0x10, + 0x05, 0x72, 0x5f, 0xbf, 0x54, 0xe3, 0xce, 0x29, 0x10, 0x36, 0xa3, 0xd6, 0xfc, + 0x69, 0x56, 0xbe, 0xaa, 0x6e, 0x35, 0x85, 0x43, 0xc6, 0x30, 0x65, 0x2d, 0x59, + 0x63, 0x1f, 0x2a, 0xde, 0x0b, 0x5a, 0x56, 0x72, 0x1e, 0x8a, 0xe8, 0x3f, 0x1c, + 0xe9, 0xc3, 0x69, 0x14, 0x06, 0xed, 0xd8, 0x37, 0x7c, 0x8b, 0x38, 0x6c, + ] + ), + test_case!( + [ + 0xc9, 0x83, 0xe9, 0xe5, 0x7b, 0x98, 0xd8, 0xe3, 0x1a, 0xc4, 0x54, 0x0b, 0x9c, + 0x7e, 0x1b, 0xd4, 0x0e, 0x30, 0x47, 0x68, 0x78, 0xd4, 0x11, 0x04, 0xca, 0x7a, + 0xa2, 0xf6, 0x02, 0x0c, 0x81, 0xa3, 0xdd, 0x66, 0x87, 0x59, 0x76, 0x3e, 0x7e, + 0x30, 0x9e, 0x25, 0xed, 0xe6, 0x73, 0xbc, 0x35, 0x3d, + ], + [ + 0xdb, 0xa0, 0x1a, 0x5a, 0x66, 0x3c, 0xc0, 0x9d, 0xe1, 0xde, 0x7c, 0xb9, 0xea, + 0x61, 0x3f, 0x03, 0x34, 0x88, 0x0d, 0xeb, + ], + [ + 0x33, 0xb7, 0xcb, 0x12, 0xcc, 0x63, 0x2d, 0x58, 0x46, 0xe1, 0xf0, 0xc2, 0x35, + 0xb1, 0x5b, 0x2e, 0x78, 0xba, 0xd3, 0xd4, 0xe2, 0x39, 0xc5, 0x6f, 0xb4, 0x22, + 0x29, 0x95, 0x9a, 0xc1, 0x9e, 0x61, + ], + [ + 0x46, 0x90, 0x27, 0x01, 0x7c, 0x8d, 0xe0, 0xa9, 0x4d, 0x7a, 0xa3, 0x66, 0x7b, + 0xc3, 0xe3, 0x63, 0xb6, 0x45, 0x5d, 0xec, 0xc7, 0x2c, 0xf4, 0x5e, 0x9c, 0xeb, + 0x1b, 0x66, 0x96, 0xa1, 0xa0, 0x65, 0x0c, 0x08, 0xfc, 0x0a, 0xfb, 0x10, 0x54, + 0x05, 0xb6, 0x12, 0xf0, 0x82, 0x31, 0xeb, 0x5b, 0x6d, + ], + [ + 0x1d, 0x20, 0xf0, 0x5a, 0x6e, 0x15, 0x80, 0xdc, 0xfc, 0x8c, 0xa8, 0x19, 0xac, + 0x6f, 0x24, 0xdc, 0xef, 0x4b, 0x7d, 0x63, 0xee, 0xb8, 0x2a, 0xa5, 0xde, 0xfe, + 0xd7, 0x71, 0x9a, 0xb5, 0xa1, 0x3c, 0x48, 0x0a, 0x0b, 0x52, 0xa8, 0x4b, 0x2d, + 0x58, 0x08, 0xd5, 0x8c, 0x40, 0x61, 0x52, 0xaa, 0x11, 0xa5, 0xed, 0x4b, 0xff, + 0xf0, 0x2d, 0x95, 0x5e, 0xb4, 0x7e, 0x01, 0xcf, 0xc3, 0xcb, 0x44, 0xf8, + ] + ), + test_case!( + [ + 0x5e, 0xfd, 0x66, 0x15, 0xf2, 0x09, 0x8e, 0x56, 0xab, 0x7f, 0xeb, 0x2b, 0x59, + 0x9d, 0xf0, 0x51, 0x8b, 0xef, 0xc3, 0xc4, 0xa2, 0xe6, 0xbc, 0x20, 0x0f, 0x7c, + 0x04, 0x72, 0x17, 0x77, 0x01, 0x66, 0x2e, 0x6b, 0x8d, 0x1d, 0xb6, 0x5b, 0x71, + 0xbc, 0x1a, 0x54, 0xa2, 0xca, 0x54, 0x17, 0xd6, 0xb9, 0xec, + ], + [ + 0xbb, 0xdd, 0x49, 0x95, 0xe9, 0x00, 0xa6, 0x4e, 0xd0, 0x3b, 0x8e, 0x73, 0x89, + 0xd4, 0x0d, 0x18, 0x71, 0xd4, 0x2c, 0x86, + ], + [ + 0xee, 0x54, 0x73, 0xe6, 0x6e, 0x57, 0xce, 0x46, 0x19, 0x9e, 0x97, 0x21, 0xce, + 0x82, 0xe2, 0x81, 0x40, 0x41, 0x9f, 0x73, 0x33, 0xe0, 0xb8, 0x02, 0xa0, 0x51, + 0xee, 0xeb, 0x29, 0x9d, 0x3b, 0x4b, + ], + [ + 0x39, 0x03, 0xbd, 0x3c, 0x08, 0x73, 0xb5, 0x5b, 0xa8, 0xb1, 0x54, 0x70, 0xac, + 0x95, 0xaa, 0x8c, 0xfe, 0x95, 0x67, 0xbe, 0xce, 0x7b, 0x6b, 0x70, 0x52, 0xd5, + 0xb0, 0xb6, 0xd0, 0xc2, 0x40, 0x3c, 0x68, 0x18, 0xd4, 0x03, 0x1d, 0xe7, 0x59, + 0x1c, 0x43, 0x3f, 0xe0, 0x7c, 0x0a, 0x4f, 0x21, 0x8f, + ], + [ + 0x29, 0x55, 0x1c, 0x3f, 0x00, 0xc2, 0x02, 0x60, 0x56, 0xac, 0xfd, 0x08, 0x02, + 0x3e, 0xc2, 0x59, 0x86, 0xe6, 0x7b, 0x45, 0xa9, 0xea, 0xff, 0x73, 0x56, 0xe6, + 0x27, 0xc6, 0x46, 0xb9, 0x38, 0x6d, 0xb4, 0x18, 0x58, 0x99, 0x14, 0x54, 0xcc, + 0x1d, 0x69, 0x08, 0xff, 0xa7, 0x1a, 0x0e, 0xe8, 0x2c, 0x9e, 0x8d, 0xec, 0xd8, + 0xee, 0x77, 0x78, 0x2e, 0xb2, 0x8c, 0xf1, 0x24, 0x1b, 0x39, 0x30, 0x23, + ] + ), + test_case!( + [ + 0xf7, 0x40, 0x5a, 0xa3, 0x7f, 0xd3, 0xd2, 0x01, 0xbe, 0xd3, 0x10, 0xdc, 0xe2, + 0x3d, 0x9c, 0xa7, 0x8c, 0x2b, 0x84, 0x67, 0xdc, 0x81, 0x08, 0x95, 0x82, 0x3b, + 0xdf, 0xe7, 0xbc, 0x22, 0x46, 0x83, 0x55, 0x77, 0xe4, 0xd9, 0xad, 0xed, 0x7c, + 0x79, 0x10, 0x44, 0x0a, 0x70, 0x06, 0xcc, 0x49, 0x82, 0xf6, 0x05, + ], + [ + 0x53, 0x7b, 0x67, 0xf4, 0x7f, 0x1b, 0x6b, 0x01, 0x17, 0xfc, 0x38, 0x6a, 0x5b, + 0xcd, 0xd9, 0xe6, 0xac, 0xd1, 0xe5, 0x87, + ], + [ + 0x5e, 0xe3, 0xd0, 0xaa, 0x3d, 0xec, 0xe1, 0xad, 0x94, 0xe9, 0xd1, 0xe7, 0xbd, + 0x5d, 0xb0, 0x1d, 0xd7, 0x17, 0xdd, 0x41, 0xa9, 0xf3, 0x89, 0x83, 0xf7, 0xf9, + 0x19, 0x9f, 0x46, 0xd6, 0xe3, 0xb6, + ], + [ + 0x6c, 0x69, 0x96, 0x9d, 0x44, 0xb2, 0x1f, 0xbc, 0xc0, 0x75, 0x01, 0x65, 0xbe, + 0xbe, 0x31, 0xc8, 0xe3, 0x9d, 0x55, 0x2f, 0xaf, 0x9b, 0x13, 0xda, 0x8d, 0xa9, + 0xec, 0x7e, 0x3d, 0xa0, 0xc7, 0xcf, 0x0d, 0x76, 0x6b, 0x12, 0xed, 0x34, 0x2e, + 0x83, 0x99, 0x46, 0x69, 0xd8, 0x2b, 0x3c, 0x66, 0x11, + ], + [ + 0x99, 0x03, 0xdf, 0x7e, 0x06, 0x6c, 0x07, 0x1e, 0x4d, 0xd6, 0x92, 0xeb, 0xf2, + 0x48, 0x72, 0xe9, 0xd3, 0x23, 0x58, 0x63, 0x77, 0x19, 0x85, 0x83, 0xe3, 0x7f, + 0xc8, 0x07, 0xc4, 0xb1, 0xa1, 0xf7, 0x65, 0x5f, 0xdc, 0x6e, 0x8a, 0xc7, 0x98, + 0xb7, 0x09, 0xac, 0x04, 0xa0, 0xc5, 0x24, 0x03, 0xd3, 0x45, 0x22, 0x69, 0x0f, + 0xf4, 0xba, 0x63, 0x67, 0x3f, 0x20, 0x18, 0x23, 0xa5, 0x9e, 0x35, 0x68, + ] + ), + test_case!( + [ + 0x2a, 0xdc, 0x00, 0x96, 0x8f, 0x27, 0x34, 0xb8, 0xd7, 0xe8, 0x6e, 0x42, 0xc1, + 0x25, 0xe7, 0xcf, 0xe1, 0x00, 0x13, 0x9c, 0x4b, 0xe3, 0x75, 0x83, 0x1a, 0x09, + 0x09, 0xe5, 0xa0, 0x93, 0x91, 0x7a, 0x8c, 0xe2, 0x13, 0xa9, 0x71, 0x48, 0x34, + 0x46, 0x67, 0x8b, 0xd9, 0x7f, 0xeb, 0xaf, 0x62, 0xc9, 0x92, 0x7d, 0x8e, + ], + [ + 0xbc, 0xad, 0x81, 0xcc, 0x0c, 0x29, 0x8f, 0xe1, 0x5d, 0x0e, 0xc1, 0xe6, 0x65, + 0x08, 0x72, 0xfc, 0x78, 0x27, 0xc5, 0x3a, + ], + [ + 0x2f, 0x2a, 0xc5, 0x04, 0x29, 0x6c, 0x27, 0xaa, 0xc7, 0x5f, 0x69, 0x79, 0xc4, + 0xe1, 0xae, 0x38, 0x61, 0xed, 0x25, 0xc6, 0xed, 0x41, 0x2f, 0x3b, 0xb8, 0xb9, + 0x41, 0x9b, 0xef, 0x4d, 0x15, 0x61, + ], + [ + 0xea, 0xc1, 0x74, 0x8c, 0x9f, 0xf7, 0x13, 0x09, 0x18, 0x72, 0x41, 0xc9, 0x98, + 0x53, 0x02, 0x22, 0xb0, 0x93, 0x79, 0xa0, 0x8e, 0xea, 0x51, 0x22, 0xa3, 0x16, + 0x0b, 0xc8, 0xa6, 0xe9, 0xc3, 0x24, 0x9d, 0xbd, 0x5e, 0x68, 0x62, 0x0e, 0xb3, + 0x41, 0xea, 0x68, 0x5e, 0xc9, 0x0f, 0xd0, 0x5b, 0xe8, + ], + [ + 0xf0, 0x50, 0x76, 0xed, 0x62, 0x4c, 0xf8, 0x35, 0xd8, 0xf3, 0x57, 0xc8, 0x98, + 0xbc, 0x5e, 0x07, 0x24, 0x3a, 0x01, 0x50, 0x9b, 0xe9, 0xef, 0x00, 0x0b, 0x97, + 0xec, 0x27, 0x96, 0x59, 0x36, 0xab, 0xd9, 0xc0, 0x1c, 0xd8, 0xc5, 0xf3, 0x7e, + 0xa9, 0xb6, 0x55, 0x05, 0x82, 0xc0, 0xe6, 0x27, 0xbb, 0xa4, 0x0f, 0xd5, 0x9f, + 0x06, 0xf0, 0x6a, 0x19, 0x94, 0x0e, 0x5a, 0xef, 0x6b, 0x1a, 0x0a, 0x3a, + ] + ), + test_case!( + [ + 0x4e, 0x8c, 0xd7, 0x32, 0x43, 0x7e, 0xdd, 0x54, 0x1b, 0x03, 0x30, 0xac, 0xac, + 0xb7, 0x0a, 0xe0, 0x18, 0xa2, 0x32, 0x9f, 0x35, 0x8e, 0xb7, 0x34, 0x2c, 0xf3, + 0xf6, 0x35, 0x8f, 0x62, 0x26, 0x42, 0x2f, 0xd4, 0x59, 0x3c, 0xc8, 0xf8, 0x58, + 0xf3, 0x0f, 0x65, 0xd8, 0xe4, 0x8c, 0x88, 0x6a, 0x4c, 0xfb, 0x14, 0x56, 0xea, + ], + [ + 0x3f, 0xb1, 0x23, 0x41, 0x2a, 0xd3, 0xdb, 0xcb, 0x43, 0x5c, 0x03, 0x1c, 0x62, + 0xd3, 0x7b, 0xf6, 0x19, 0x92, 0x9e, 0x72, + ], + [ + 0xea, 0x7c, 0x5d, 0x3f, 0x37, 0x10, 0x32, 0x2e, 0x22, 0x00, 0x71, 0x4e, 0x5c, + 0xd7, 0xe3, 0x90, 0x73, 0x51, 0x0c, 0x11, 0xf0, 0xba, 0x0c, 0x70, 0xcf, 0x23, + 0x56, 0x6f, 0x1a, 0xfa, 0xe4, 0x86, + ], + [ + 0x78, 0x33, 0xa4, 0xba, 0x03, 0xb1, 0x09, 0x54, 0xfe, 0x76, 0x12, 0xe5, 0xb0, + 0xbd, 0xf8, 0x1d, 0xe6, 0x6f, 0xfd, 0x63, 0xe8, 0x5c, 0x63, 0x40, 0x25, 0xde, + 0xb6, 0x3f, 0x02, 0xca, 0x55, 0xd5, 0x03, 0xcd, 0x9d, 0xd8, 0x8a, 0xf3, 0x34, + 0x28, 0xe7, 0x82, 0xdd, 0x46, 0xdc, 0x14, 0xb6, 0x17, + ], + [ + 0x2d, 0xb5, 0xba, 0xf4, 0xd1, 0x1b, 0xc5, 0x70, 0x04, 0xc0, 0xf8, 0x99, 0x39, + 0xbd, 0x3f, 0x65, 0x16, 0xba, 0x26, 0xab, 0x5a, 0xcb, 0x5e, 0x13, 0x45, 0xde, + 0xa8, 0x4c, 0x13, 0x8f, 0x05, 0x98, 0x74, 0x47, 0x04, 0x11, 0x72, 0xa7, 0xe8, + 0x81, 0x45, 0x83, 0x32, 0x1e, 0x9e, 0xb5, 0x1b, 0x08, 0xa6, 0x7e, 0xe0, 0x75, + 0x05, 0x89, 0x5a, 0x69, 0x18, 0xa7, 0x0a, 0x00, 0x9e, 0x00, 0xa0, 0x07, + ] + ), + test_case!( + [ + 0x7e, 0x5a, 0xc5, 0x2c, 0xec, 0x3a, 0xcc, 0xfd, 0x72, 0x35, 0x5f, 0x45, 0xf1, + 0xbb, 0x36, 0x53, 0xb7, 0x3c, 0xd8, 0x9d, 0xed, 0x39, 0x51, 0x9f, 0xb7, 0x98, + 0xcd, 0x88, 0x0f, 0x95, 0x63, 0xa8, 0x1f, 0x45, 0x9e, 0xbc, 0x9b, 0xfc, 0x2b, + 0x5a, 0x7d, 0x56, 0xd8, 0xfc, 0x8c, 0x09, 0xaa, 0x72, 0xdb, 0x2c, 0x7d, 0x9a, + 0x58, + ], + [ + 0x2c, 0xb8, 0xb5, 0x49, 0xd8, 0x10, 0x80, 0x9d, 0xed, 0xb9, 0x3d, 0xcb, 0xfe, + 0xb9, 0x00, 0xd6, 0xae, 0x04, 0x77, 0xff, + ], + [ + 0x22, 0x1f, 0x10, 0x7a, 0xdc, 0xc1, 0x84, 0xfa, 0x55, 0x89, 0xa2, 0x02, 0xad, + 0x1d, 0x5e, 0xe8, 0xce, 0xaf, 0x35, 0x0a, 0x1b, 0xc9, 0x23, 0x0a, 0x9a, 0x44, + 0x90, 0x72, 0xc6, 0x41, 0x4e, 0xb4, + ], + [ + 0xa5, 0x9b, 0xf6, 0x79, 0xc0, 0x07, 0xb6, 0xcc, 0xbf, 0xcd, 0xfa, 0x56, 0x07, + 0x3a, 0xb8, 0x95, 0x59, 0x49, 0x27, 0x4e, 0x1e, 0xe8, 0x75, 0x9b, 0x04, 0x9d, + 0xa5, 0xc8, 0x0e, 0xcd, 0x8b, 0xa7, 0xc0, 0xc5, 0x8e, 0xb1, 0x4d, 0xa0, 0x25, + 0x08, 0xbe, 0x37, 0xc1, 0x6f, 0xd6, 0x59, 0x09, 0x61, + ], + [ + 0xc0, 0xa3, 0x5e, 0x5b, 0x31, 0xd0, 0xc0, 0x3c, 0xd1, 0x37, 0xd3, 0x25, 0x22, + 0x50, 0xca, 0xbd, 0xa4, 0x85, 0x30, 0x64, 0xaf, 0x6f, 0xa1, 0xec, 0x0c, 0xc3, + 0x79, 0x08, 0xd2, 0x06, 0xaf, 0xd1, 0xd4, 0x43, 0xb9, 0xe0, 0xf6, 0x14, 0x3b, + 0x7c, 0xf2, 0xf8, 0x00, 0x47, 0x15, 0x85, 0xfd, 0xca, 0x5a, 0x65, 0xc7, 0x80, + 0xe1, 0xd0, 0x57, 0x79, 0x84, 0x0f, 0xd0, 0xe3, 0x12, 0x86, 0x99, 0x7e, + ] + ), + test_case!( + [ + 0x4b, 0x3c, 0x61, 0xeb, 0x1a, 0x4f, 0x06, 0x8a, 0x24, 0xbc, 0xed, 0x90, 0xfd, + 0xd3, 0x00, 0xc8, 0xf2, 0xf7, 0xb4, 0x01, 0x57, 0x1c, 0x33, 0x94, 0x48, 0x7f, + 0x34, 0x5e, 0x89, 0xe4, 0x1c, 0xe4, 0xe0, 0x09, 0xe6, 0x12, 0xdf, 0x1b, 0x8e, + 0x14, 0x13, 0x62, 0x32, 0xc3, 0x30, 0x06, 0x87, 0xb2, 0x22, 0xaf, 0x5e, 0xb8, + 0x0b, 0xae, + ], + [ + 0x3d, 0x11, 0x99, 0xb2, 0xd4, 0x58, 0x02, 0x6e, 0x1e, 0x24, 0xe6, 0x7d, 0x91, + 0x10, 0x7b, 0x3f, 0xd9, 0x58, 0xc2, 0xb7, + ], + [ + 0x21, 0x4c, 0x6e, 0x88, 0x42, 0xb9, 0xc2, 0xe0, 0x33, 0x6d, 0xb4, 0x5f, 0x42, + 0x90, 0x16, 0xf1, 0x1d, 0x02, 0xf2, 0x1c, 0xba, 0xbc, 0xb9, 0xb5, 0x2d, 0x7a, + 0x16, 0xd0, 0x99, 0xc2, 0x93, 0x52, + ], + [ + 0x33, 0x30, 0x2c, 0x21, 0xca, 0x13, 0x47, 0x9b, 0xd7, 0xb6, 0x2d, 0x43, 0x65, + 0x5f, 0xe2, 0xca, 0xbc, 0x5a, 0xdd, 0x3c, 0xd7, 0x68, 0xd9, 0xbe, 0x24, 0xae, + 0x77, 0xe1, 0x6a, 0xf7, 0x01, 0x9f, 0xcd, 0xf8, 0x2d, 0xc0, 0xeb, 0xa0, 0xc6, + 0x47, 0x73, 0xe3, 0x7c, 0x01, 0xf9, 0xf4, 0xbe, 0xd2, + ], + [ + 0x99, 0x89, 0xea, 0x7f, 0xdb, 0x37, 0x99, 0xb2, 0xc7, 0x4e, 0xc5, 0x7e, 0x67, + 0x08, 0x6b, 0xc7, 0x74, 0x79, 0xde, 0xaa, 0x73, 0x6b, 0x48, 0x0e, 0x82, 0x56, + 0x7f, 0x82, 0x50, 0xf0, 0xda, 0x9b, 0x70, 0xf4, 0x76, 0x35, 0x58, 0x06, 0x3f, + 0x15, 0x78, 0xef, 0x3e, 0x0d, 0x28, 0x3d, 0x41, 0x34, 0x85, 0xe9, 0x43, 0xde, + 0xec, 0xd8, 0x38, 0x90, 0xb3, 0xf1, 0x58, 0x7d, 0x38, 0x24, 0xbc, 0x73, + ] + ), + test_case!( + [ + 0x20, 0x12, 0xcd, 0x3f, 0x56, 0x5d, 0x24, 0x82, 0x80, 0x42, 0xfe, 0xa7, 0xba, + 0xca, 0xbd, 0x3a, 0x7b, 0x78, 0xda, 0x45, 0x39, 0x56, 0x34, 0x5d, 0x9b, 0x64, + 0x26, 0x58, 0x83, 0xb8, 0x00, 0x09, 0x17, 0x4c, 0xe4, 0x94, 0x5d, 0xff, 0x8e, + 0xb7, 0xf4, 0x8b, 0x58, 0xe9, 0x93, 0xd6, 0x60, 0x3c, 0xec, 0xc3, 0x26, 0xfa, + 0x7a, 0xf5, 0x9c, + ], + [ + 0x02, 0x7e, 0x9c, 0x5b, 0x82, 0x8d, 0xf6, 0x5b, 0x8f, 0xad, 0xc2, 0x72, 0x92, + 0xdf, 0xb6, 0x7e, 0x3b, 0x83, 0xfc, 0x78, + ], + [ + 0x69, 0x30, 0x2a, 0x89, 0xc1, 0x9e, 0x2b, 0xaf, 0x91, 0x15, 0x25, 0x51, 0x56, + 0xbf, 0xca, 0xe2, 0xc3, 0x09, 0x12, 0xe6, 0x68, 0xfe, 0x6b, 0x95, 0x33, 0x10, + 0xdf, 0xcc, 0x0e, 0x98, 0x77, 0x88, + ], + [ + 0x16, 0x45, 0xa0, 0x94, 0xb3, 0x6f, 0x5f, 0xff, 0xb4, 0x1c, 0x38, 0xdb, 0x38, + 0xc5, 0xe1, 0xe0, 0xa5, 0x3f, 0xfd, 0x92, 0x68, 0x70, 0xf3, 0x17, 0xc8, 0x7f, + 0xbd, 0xb0, 0xc0, 0x18, 0xc3, 0x03, 0x7b, 0xc8, 0xe4, 0xc6, 0xd1, 0xf6, 0x4c, + 0x0d, 0x16, 0x9a, 0x68, 0xaf, 0x2d, 0xb3, 0x74, 0x86, + ], + [ + 0x08, 0xba, 0x37, 0x6b, 0xc4, 0x2d, 0x03, 0xb0, 0x3a, 0x90, 0xad, 0x14, 0xc3, + 0xda, 0x8c, 0xff, 0x21, 0x8e, 0xf9, 0xf6, 0xae, 0x69, 0x0b, 0xd1, 0xe2, 0xb7, + 0x46, 0x0a, 0x8b, 0x46, 0xbb, 0xdf, 0x0b, 0x9a, 0xaf, 0x63, 0xc0, 0x73, 0xcc, + 0xe2, 0xf6, 0x3a, 0xe6, 0x7f, 0x68, 0xbc, 0x39, 0x38, 0x29, 0x79, 0x03, 0xb7, + 0x99, 0xf1, 0x62, 0x29, 0x7c, 0xb9, 0x3c, 0x8b, 0xbb, 0x48, 0x82, 0x21, + ] + ), + test_case!( + [ + 0x83, 0x6a, 0xb3, 0xfd, 0x64, 0x00, 0x02, 0x41, 0x8e, 0x5b, 0xec, 0xc1, 0x21, + 0x2f, 0x1e, 0xaa, 0xe3, 0xf9, 0xd4, 0xe4, 0x21, 0xa6, 0x68, 0x15, 0xd6, 0x58, + 0x18, 0x72, 0x2f, 0x3b, 0x17, 0x9c, 0xfc, 0x71, 0x7d, 0x49, 0xa4, 0x92, 0x7b, + 0x93, 0x87, 0x52, 0xce, 0x71, 0x7f, 0xc6, 0x83, 0x83, 0xc5, 0x37, 0x53, 0xa0, + 0x3c, 0x8e, 0x21, 0x91, + ], + [ + 0x1d, 0xd6, 0xc0, 0xad, 0x6c, 0x6e, 0xa5, 0x76, 0xbc, 0x67, 0x37, 0x05, 0x87, + 0x8b, 0x17, 0xc4, 0x80, 0x9f, 0xaf, 0x30, + ], + [ + 0xfb, 0xbf, 0x79, 0x20, 0xaf, 0xcd, 0xb5, 0xaa, 0xf3, 0x4f, 0xca, 0xc9, 0x45, + 0xa7, 0x49, 0x1a, 0x85, 0x99, 0x37, 0xaf, 0xbd, 0x9c, 0x2c, 0x1c, 0xfe, 0xe8, + 0xe3, 0x20, 0x4d, 0x18, 0x66, 0x1e, + ], + [ + 0xdf, 0x45, 0x40, 0xe9, 0x93, 0xb7, 0xee, 0x62, 0x41, 0xa1, 0x21, 0x0f, 0xd8, + 0x23, 0x9e, 0x6b, 0xa2, 0xc0, 0x9c, 0x4a, 0x0b, 0xff, 0xa9, 0x08, 0x7e, 0x35, + 0xda, 0x5b, 0x4b, 0x76, 0x7e, 0x37, 0x24, 0x14, 0x4f, 0x1c, 0xfa, 0xa6, 0x20, + 0xe7, 0xa2, 0xa7, 0x90, 0x98, 0x69, 0x15, 0x4b, 0x28, + ], + [ + 0x03, 0xa4, 0x15, 0x16, 0x50, 0x00, 0x20, 0xb8, 0xf7, 0x6b, 0x94, 0xce, 0xa9, + 0x06, 0xf7, 0x1e, 0x88, 0x54, 0xe9, 0x15, 0xad, 0xe5, 0x0b, 0x4a, 0xa6, 0x5e, + 0x8b, 0x43, 0xf8, 0x9b, 0x5b, 0x0a, 0x49, 0x52, 0x49, 0x6c, 0x16, 0xec, 0x51, + 0xac, 0x2a, 0x0d, 0xb1, 0x89, 0x4b, 0x75, 0x97, 0x5c, 0xea, 0x4e, 0x52, 0xd2, + 0x06, 0x68, 0x8b, 0x13, 0xd8, 0x9b, 0x49, 0x82, 0xb9, 0x9b, 0x03, 0xc7, + ] + ), + test_case!( + [ + 0x74, 0xda, 0xd3, 0x9e, 0xb7, 0x28, 0x06, 0x8e, 0x54, 0x04, 0x23, 0x02, 0x1a, + 0xf0, 0x40, 0xc8, 0xdf, 0xa1, 0xc9, 0x44, 0xca, 0x27, 0x2f, 0x5a, 0xe6, 0x10, + 0x6d, 0x57, 0x42, 0x39, 0x4f, 0x8a, 0x11, 0x49, 0x23, 0x6d, 0xf2, 0x2a, 0x01, + 0x61, 0xb8, 0xd0, 0xfe, 0x7d, 0xb0, 0xd4, 0x6e, 0x2e, 0xf2, 0xfd, 0x4f, 0x5d, + 0x15, 0x71, 0x76, 0x4d, 0xbb, + ], + [ + 0x9e, 0x91, 0x66, 0xa2, 0x2d, 0xfc, 0x7f, 0xf2, 0x55, 0xee, 0x53, 0x06, 0x81, + 0xf1, 0x08, 0x8e, 0xf8, 0xfe, 0x86, 0x35, + ], + [ + 0xeb, 0xc3, 0xeb, 0x13, 0x8e, 0xa3, 0x15, 0x39, 0xd3, 0xcb, 0x64, 0xc4, 0xa8, + 0xf8, 0x39, 0xe3, 0x0c, 0x00, 0x9b, 0x57, 0x93, 0x8f, 0x71, 0x43, 0xed, 0xa2, + 0xe8, 0x9c, 0x22, 0x7b, 0xbd, 0xc1, + ], + [ + 0xd8, 0x62, 0x44, 0xfd, 0xed, 0x54, 0xbd, 0xe2, 0xae, 0xa0, 0x11, 0xe9, 0x56, + 0x2d, 0x7f, 0x0c, 0x43, 0x54, 0xc5, 0x40, 0xe6, 0x01, 0x99, 0x34, 0xd1, 0xe2, + 0x4d, 0xa9, 0x5d, 0x7b, 0x08, 0xaf, 0x02, 0x7f, 0x7d, 0x14, 0x1f, 0x31, 0x14, + 0xa5, 0xdd, 0x7a, 0x80, 0x2c, 0x53, 0x78, 0x18, 0x5c, + ], + [ + 0xe4, 0x0d, 0x4b, 0xae, 0x97, 0x00, 0x68, 0x9d, 0xd6, 0x03, 0x7c, 0x5a, 0xae, + 0x27, 0x28, 0x3b, 0x55, 0x81, 0x9c, 0xe7, 0xbe, 0x55, 0x80, 0xc5, 0x7c, 0xcd, + 0x3d, 0xae, 0x22, 0x6d, 0x5f, 0x38, 0xb2, 0x1a, 0xc0, 0x7f, 0xee, 0x43, 0x7d, + 0xa1, 0x28, 0x2f, 0x02, 0xb0, 0xa6, 0x46, 0xf2, 0x52, 0x62, 0x27, 0x35, 0xc4, + 0x1d, 0x1a, 0xad, 0xb7, 0x8d, 0x4e, 0x53, 0x91, 0x47, 0x6c, 0x87, 0xd7, + ] + ), + test_case!( + [ + 0x3e, 0xc0, 0x06, 0xb3, 0x2f, 0x90, 0xfc, 0x0b, 0x3f, 0x56, 0x5b, 0x7c, 0x81, + 0x1b, 0xe2, 0xc8, 0x67, 0x07, 0xc1, 0x34, 0x16, 0x93, 0x23, 0x0d, 0xdc, 0x9b, + 0xc4, 0x3f, 0xf7, 0x7b, 0x44, 0x4b, 0x49, 0x8f, 0x21, 0x23, 0xd2, 0xa2, 0x7e, + 0x88, 0xa9, 0x51, 0xbc, 0x7e, 0x33, 0x7c, 0x10, 0xf1, 0x10, 0x38, 0x3b, 0x7d, + 0xed, 0x92, 0xb0, 0x8b, 0x56, 0x01, + ], + [ + 0xa0, 0x7f, 0x80, 0xd6, 0xa8, 0x22, 0xd8, 0x66, 0xc7, 0xba, 0xed, 0x7d, 0x6f, + 0x10, 0xeb, 0x33, 0x9e, 0xd5, 0xcf, 0x79, + ], + [ + 0xb0, 0xd1, 0xa5, 0xa7, 0xac, 0x4e, 0x49, 0xcc, 0xad, 0xe9, 0xca, 0x1e, 0x25, + 0x9f, 0x8f, 0x41, 0x95, 0x8e, 0x6b, 0x6a, 0x9d, 0x71, 0x0b, 0xb5, 0x18, 0x3d, + 0xf4, 0x3e, 0xd5, 0xf8, 0x46, 0xc0, + ], + [ + 0x4c, 0x1b, 0x33, 0xe1, 0x5c, 0xfa, 0x2a, 0xd8, 0xc5, 0x93, 0x01, 0x25, 0x42, + 0x97, 0x94, 0x61, 0xb4, 0x42, 0x0a, 0x9d, 0xa8, 0x35, 0x6a, 0x37, 0xe2, 0xc3, + 0x3d, 0xd4, 0x02, 0x21, 0x62, 0x4c, 0xc5, 0x6a, 0x14, 0x25, 0x39, 0xc6, 0x4b, + 0x57, 0x8e, 0x43, 0xa0, 0x37, 0xaa, 0xf8, 0xf7, 0x34, + ], + [ + 0xe3, 0x8f, 0xc5, 0x73, 0xbc, 0x6d, 0x2c, 0xcf, 0x71, 0x4e, 0x09, 0x0c, 0xfd, + 0x59, 0xae, 0xbb, 0xc6, 0xf6, 0xac, 0x1d, 0x10, 0xd4, 0x21, 0xf9, 0xeb, 0xc5, + 0x26, 0xba, 0xaa, 0x15, 0x62, 0x7d, 0x8f, 0x3b, 0xb1, 0x59, 0x42, 0x3b, 0x65, + 0x1b, 0x2f, 0x46, 0x88, 0xbb, 0x44, 0x5d, 0x9a, 0x0a, 0x34, 0xde, 0x6e, 0x8c, + 0x76, 0xfb, 0x97, 0xd7, 0x74, 0xc2, 0x80, 0x39, 0x52, 0xce, 0xdf, 0xe5, + ] + ), + test_case!( + [ + 0xea, 0x08, 0xf5, 0xaf, 0xfc, 0x45, 0x8a, 0xec, 0xba, 0x30, 0x0e, 0x12, 0xc4, + 0x61, 0xa5, 0x07, 0x83, 0xe6, 0x7e, 0xc4, 0xfa, 0x97, 0x60, 0x9b, 0xa0, 0xa4, + 0x05, 0x43, 0xe8, 0x0a, 0x1a, 0xe4, 0x6a, 0x80, 0xf4, 0x90, 0x0a, 0xbd, 0xe7, + 0xa3, 0x49, 0x72, 0x2c, 0x25, 0x9b, 0x8d, 0x1a, 0x05, 0xd5, 0xa5, 0x97, 0xe9, + 0x50, 0x88, 0xea, 0xcb, 0x2a, 0x1b, 0xdb, + ], + [ + 0x5b, 0x4d, 0xb6, 0x1a, 0xb2, 0xc8, 0x2a, 0xd6, 0xb3, 0xe6, 0xe1, 0x11, 0x21, + 0x96, 0x15, 0x92, 0x8b, 0xfe, 0x61, 0x67, + ], + [ + 0x25, 0x7f, 0x71, 0xb1, 0xa7, 0xa3, 0xd2, 0x3d, 0xdd, 0x75, 0x3a, 0x18, 0x0d, + 0xa6, 0xd2, 0x4c, 0xc7, 0x90, 0x5d, 0x58, 0xeb, 0x98, 0x38, 0x6a, 0xca, 0x68, + 0x2d, 0x22, 0x35, 0x6d, 0xe7, 0xe9, + ], + [ + 0xdd, 0x9d, 0x0c, 0x30, 0x11, 0x1b, 0xf7, 0x6a, 0x30, 0x65, 0xb4, 0xa3, 0x0b, + 0x4a, 0x32, 0xa5, 0xcb, 0x48, 0x8e, 0x5e, 0x97, 0x80, 0x42, 0x57, 0x55, 0x92, + 0xb9, 0x7f, 0x62, 0xb6, 0xeb, 0xfe, 0x35, 0x08, 0x45, 0x71, 0x55, 0x75, 0xc7, + 0x71, 0x07, 0x3d, 0x4f, 0xb5, 0x90, 0xd6, 0xec, 0xcb, + ], + [ + 0xd4, 0xc8, 0x0b, 0x56, 0x4b, 0x9d, 0x1a, 0x66, 0x1a, 0x77, 0xb0, 0x3c, 0xb8, + 0x2e, 0xd6, 0xcf, 0xe0, 0x4b, 0xe7, 0xd0, 0x1a, 0xde, 0x00, 0xc3, 0xf3, 0xbc, + 0x73, 0x1d, 0xd2, 0x87, 0x19, 0xb9, 0xdd, 0x23, 0x05, 0x92, 0x62, 0x85, 0x0d, + 0x80, 0x53, 0xb4, 0x66, 0x51, 0x0e, 0x80, 0x41, 0x42, 0xaa, 0xcd, 0x38, 0xec, + 0x7b, 0x64, 0xe7, 0x78, 0xf9, 0x42, 0xe4, 0xd3, 0x85, 0x4b, 0x03, 0xf7, + ] + ), + test_case!( + [ + 0x49, 0x3d, 0x3b, 0x5f, 0x12, 0x45, 0xeb, 0x38, 0x55, 0xc2, 0x4c, 0x4f, 0x48, + 0x3e, 0x58, 0xb1, 0x04, 0x70, 0xe1, 0xb7, 0x7f, 0xcc, 0x8b, 0x68, 0x27, 0xb0, + 0x1e, 0xab, 0xd8, 0x17, 0xa5, 0xbe, 0xd4, 0xbf, 0xf4, 0x43, 0x4a, 0x49, 0xd8, + 0xb7, 0x13, 0xe8, 0xa7, 0x4a, 0xae, 0x93, 0x3e, 0x97, 0xa0, 0xbf, 0x41, 0xa1, + 0x7e, 0x91, 0x0e, 0x75, 0x41, 0x5f, 0x66, 0x7d, + ], + [ + 0x75, 0xe7, 0xa8, 0x12, 0x52, 0xda, 0xf3, 0xfe, 0x57, 0x92, 0xe3, 0x40, 0x3e, + 0x5e, 0x61, 0x11, 0xb0, 0x3a, 0x72, 0x09, + ], + [ + 0x9e, 0x29, 0xa7, 0xfc, 0xef, 0x76, 0x4b, 0x1f, 0x69, 0x2a, 0x81, 0xda, 0xa2, + 0xd3, 0xa2, 0x11, 0x61, 0x15, 0xdf, 0xc4, 0x99, 0xde, 0xd3, 0x4c, 0xd9, 0x1e, + 0x6a, 0x73, 0xc8, 0xe9, 0xd2, 0x7e, + ], + [ + 0x0c, 0xbb, 0x52, 0xe0, 0x3f, 0x97, 0x41, 0x60, 0xd5, 0x59, 0xbe, 0x36, 0xac, + 0xd9, 0xc6, 0x2e, 0xb6, 0x04, 0x0c, 0x0a, 0x37, 0x44, 0x3b, 0x60, 0x22, 0x96, + 0x23, 0xd8, 0x31, 0x56, 0x74, 0x6b, 0x99, 0xdb, 0xd5, 0xc6, 0x3d, 0x2b, 0x47, + 0xae, 0xa7, 0x2a, 0x7a, 0xc0, 0xee, 0xa5, 0x98, 0x62, + ], + [ + 0x3c, 0xa7, 0xeb, 0xe2, 0x13, 0x88, 0x3d, 0x2a, 0xc9, 0x4f, 0x67, 0xf9, 0x43, + 0xea, 0x07, 0x75, 0xd9, 0x40, 0x28, 0x5a, 0x48, 0xdd, 0x0e, 0xc4, 0x63, 0xa9, + 0x9c, 0x77, 0x3d, 0xed, 0x07, 0x3b, 0x5c, 0xdf, 0x62, 0x04, 0xf4, 0x64, 0x85, + 0x35, 0x8e, 0x88, 0xe9, 0x4b, 0x86, 0x78, 0x5d, 0x71, 0x3d, 0x97, 0x27, 0x27, + 0x72, 0x56, 0xc7, 0xd3, 0x5d, 0xd5, 0x2e, 0x7c, 0xee, 0xdd, 0x74, 0x11, + ] + ), + test_case!( + [ + 0xd7, 0x63, 0x65, 0xc1, 0x3f, 0x6d, 0x92, 0xfe, 0x90, 0xf0, 0x8f, 0x2c, 0xba, + 0x73, 0x2a, 0x2b, 0x88, 0x9e, 0x5d, 0xe0, 0x0c, 0x65, 0xea, 0xed, 0xf5, 0xaa, + 0x5c, 0x6c, 0x06, 0x94, 0x65, 0xde, 0x75, 0x9e, 0x14, 0x1e, 0x2b, 0x7f, 0x73, + 0xdb, 0xb7, 0x3b, 0xb7, 0x8e, 0x69, 0xc5, 0x0e, 0xf7, 0xaa, 0x77, 0x6c, 0x8b, + 0xbc, 0x1a, 0x30, 0x00, 0xd3, 0xa2, 0x77, 0x42, 0x7f, + ], + [ + 0x0b, 0xa6, 0xb9, 0x91, 0x4b, 0x19, 0xe3, 0xea, 0x54, 0x9b, 0x82, 0x41, 0x09, + 0xd8, 0x1d, 0x99, 0x74, 0xa0, 0x95, 0x16, + ], + [ + 0xd0, 0xf1, 0x55, 0x65, 0x17, 0xc2, 0x1e, 0x4f, 0x61, 0xc9, 0xcb, 0xcc, 0x83, + 0x27, 0x0d, 0x29, 0x04, 0x6f, 0x86, 0x91, 0x07, 0xd8, 0x0a, 0x76, 0x37, 0x0d, + 0x0c, 0x43, 0x75, 0xd8, 0xca, 0xce, + ], + [ + 0x4f, 0x42, 0x31, 0xc0, 0xce, 0x03, 0xf7, 0x8c, 0x63, 0x29, 0xb1, 0x36, 0xde, + 0x8d, 0x82, 0xcb, 0x06, 0xbf, 0x55, 0x2d, 0x1f, 0x9a, 0xa3, 0x20, 0x63, 0x67, + 0xcb, 0xdc, 0x54, 0x9b, 0x92, 0xdd, 0xac, 0x30, 0x3b, 0x79, 0xcf, 0x7c, 0xe3, + 0x46, 0xac, 0x4a, 0xfe, 0xd7, 0x37, 0xbd, 0x79, 0x5e, + ], + [ + 0x40, 0x36, 0xe6, 0xf5, 0xfa, 0xf5, 0x70, 0x3e, 0x41, 0xd2, 0x58, 0x81, 0x59, + 0x16, 0x23, 0xce, 0x22, 0x4a, 0x9b, 0xb0, 0x0c, 0xd0, 0xf9, 0x72, 0x78, 0x6a, + 0xa4, 0x43, 0x5b, 0x69, 0x96, 0xfc, 0xab, 0x45, 0x87, 0x81, 0xe9, 0xa4, 0x6c, + 0x3c, 0x2f, 0xc9, 0x57, 0x81, 0xec, 0xc7, 0x16, 0x53, 0x18, 0xf3, 0xfa, 0xd5, + 0xdf, 0x09, 0xe0, 0x08, 0xf2, 0xe7, 0x93, 0xc7, 0xcc, 0x7b, 0x43, 0xac, + ] + ), + test_case!( + [ + 0x51, 0xda, 0x57, 0x9f, 0x2f, 0x75, 0x31, 0x51, 0x49, 0xd2, 0x83, 0xa4, 0x78, + 0xb2, 0xa8, 0x20, 0x43, 0x04, 0x09, 0xad, 0xfd, 0x17, 0x31, 0xbd, 0xea, 0xd2, + 0x84, 0x67, 0x53, 0x6f, 0x0b, 0x2f, 0xaa, 0x40, 0x23, 0xdc, 0x90, 0x34, 0x1a, + 0x27, 0x0e, 0x90, 0x34, 0x6f, 0x9c, 0xd1, 0x03, 0xa1, 0x16, 0x64, 0x1e, 0x6c, + 0x59, 0xa4, 0xc9, 0x4e, 0xb6, 0xc8, 0x28, 0xfb, 0x3d, 0x49, + ], + [ + 0xfa, 0x72, 0xd9, 0x0c, 0x96, 0x70, 0xd0, 0xf5, 0xec, 0x5d, 0xda, 0x8d, 0xde, + 0x87, 0x2d, 0x90, 0xba, 0x08, 0x82, 0xd9, + ], + [ + 0x98, 0xe0, 0xd1, 0x68, 0xf6, 0xd1, 0xd4, 0xa5, 0xf1, 0xad, 0x1c, 0x86, 0x22, + 0x63, 0x1b, 0x40, 0x88, 0x6f, 0xde, 0x1c, 0x17, 0xb2, 0x7a, 0xa5, 0x10, 0x01, + 0x59, 0xc6, 0x1f, 0xf8, 0xe2, 0xac, + ], + [ + 0x8f, 0xab, 0xf0, 0x54, 0x18, 0xfe, 0xdc, 0x5e, 0xd2, 0x21, 0x94, 0x7d, 0x1e, + 0x0f, 0xc6, 0x8d, 0xaa, 0xc7, 0xf7, 0xcb, 0x9b, 0xf6, 0x74, 0x22, 0xb2, 0xdd, + 0xd2, 0x5c, 0x69, 0x32, 0xc8, 0x25, 0x93, 0x3f, 0x88, 0xf3, 0x53, 0xfb, 0x8d, + 0x6e, 0x79, 0xeb, 0x3a, 0x9f, 0x92, 0xd5, 0x6d, 0x01, + ], + [ + 0xdd, 0x7d, 0x95, 0xa2, 0xc0, 0x34, 0xa0, 0xf0, 0xd6, 0xb7, 0x06, 0xd6, 0x03, + 0x98, 0xc2, 0x12, 0x76, 0x24, 0x5e, 0xe6, 0x55, 0x95, 0xdb, 0x51, 0xb3, 0x7b, + 0x16, 0x40, 0x3a, 0xf5, 0xd7, 0x2b, 0x88, 0x72, 0xfc, 0x1b, 0x29, 0x37, 0xe7, + 0x2c, 0x55, 0xd0, 0xbd, 0x50, 0xc6, 0xa7, 0x86, 0xb9, 0xf7, 0xba, 0xcb, 0xad, + 0x06, 0x38, 0x86, 0x38, 0x75, 0x3f, 0xd0, 0xb0, 0x3f, 0x19, 0xc0, 0x7c, + ] + ), + test_case!( + [ + 0x9f, 0x4f, 0x0c, 0x66, 0x5b, 0xe4, 0x16, 0x82, 0x77, 0xb5, 0x9b, 0xea, 0x83, + 0xe2, 0x74, 0x44, 0x9f, 0x90, 0x8d, 0x82, 0x34, 0xae, 0xf4, 0xdb, 0x10, 0x04, + 0x26, 0x57, 0x36, 0x4e, 0x97, 0x85, 0xa3, 0x01, 0xa0, 0x04, 0xe6, 0x32, 0x1b, + 0xfb, 0x5a, 0x41, 0x10, 0xcf, 0x56, 0xa4, 0x74, 0xb2, 0xfe, 0x5c, 0xbb, 0xc7, + 0x59, 0x15, 0xca, 0xd8, 0x73, 0x3e, 0x9f, 0x03, 0xb3, 0x04, 0xa1, + ], + [ + 0x31, 0x63, 0xe9, 0x1a, 0x83, 0x3d, 0xf0, 0x94, 0xbd, 0x55, 0xcc, 0x8e, 0x3b, + 0x84, 0xa3, 0x2f, 0xb7, 0x1e, 0xca, 0x98, + ], + [ + 0xe6, 0xbb, 0xa4, 0x1e, 0xd4, 0x12, 0x08, 0xe6, 0xbc, 0xb5, 0xd6, 0x08, 0x95, + 0x8a, 0x21, 0x72, 0x14, 0xd3, 0x96, 0xd2, 0x96, 0x27, 0xf7, 0xf2, 0x7d, 0x91, + 0x4a, 0x6c, 0xb0, 0xeb, 0x90, 0xef, + ], + [ + 0xe7, 0x9c, 0x3e, 0x7e, 0x14, 0xa9, 0xef, 0x71, 0x82, 0xb0, 0x13, 0xea, 0xdc, + 0xb4, 0x9f, 0x12, 0x32, 0x2c, 0xd8, 0xc3, 0x23, 0xfd, 0x22, 0x34, 0xf2, 0xec, + 0xd8, 0x0b, 0x8a, 0xa2, 0x87, 0x49, 0x56, 0x0d, 0xb8, 0x88, 0x03, 0xd5, 0xd1, + 0x3c, 0x6d, 0x0d, 0xf2, 0x01, 0x46, 0x05, 0x3e, 0x0c, + ], + [ + 0x50, 0xf7, 0x59, 0x2c, 0x43, 0x52, 0x95, 0xd8, 0xac, 0xff, 0xc8, 0xf9, 0xad, + 0x7d, 0x53, 0x94, 0x8b, 0x26, 0xb5, 0xfa, 0xd6, 0xdd, 0x96, 0xfa, 0x2c, 0x56, + 0x9c, 0x19, 0xcb, 0xa0, 0x4c, 0xf4, 0xad, 0xea, 0xf3, 0xbd, 0xb2, 0x13, 0x01, + 0xf5, 0x54, 0x29, 0x00, 0xc8, 0xc4, 0x9f, 0xed, 0xf5, 0x71, 0x10, 0x82, 0xa1, + 0x41, 0x47, 0x51, 0x86, 0x90, 0xe4, 0xf3, 0xcf, 0xc4, 0xa0, 0x9b, 0xd8, + ] + ), + test_case!( + [ + 0xb8, 0xe3, 0x7b, 0x37, 0xed, 0x17, 0xcd, 0x85, 0xfe, 0x05, 0x07, 0x74, 0x51, + 0xff, 0xcd, 0x0b, 0x0a, 0xc4, 0xfc, 0xf0, 0xa5, 0xe0, 0x81, 0xd9, 0xdd, 0xc5, + 0xa6, 0x42, 0x76, 0x92, 0x6d, 0xaf, 0x89, 0x36, 0xed, 0x13, 0x51, 0xe0, 0x1e, + 0xe6, 0x73, 0x7a, 0xbc, 0x17, 0xb8, 0x3d, 0x34, 0x11, 0x32, 0x1a, 0xab, 0xaa, + 0x2c, 0xce, 0x4b, 0x70, 0x58, 0xe4, 0xfc, 0x80, 0x94, 0x17, 0xc9, 0x43, + ], + [ + 0x26, 0xc1, 0xd3, 0x8f, 0x3e, 0x50, 0xe3, 0x8e, 0x1e, 0xea, 0x6f, 0x03, 0xbf, + 0xb5, 0x39, 0x30, 0x0f, 0xa8, 0xc5, 0x8a, + ], + [ + 0xc1, 0xc3, 0x88, 0xbc, 0xfb, 0x88, 0x27, 0xac, 0xa2, 0x88, 0xa5, 0xeb, 0xc1, + 0xa9, 0xa8, 0xdb, 0xab, 0x3b, 0xf9, 0xa0, 0xa4, 0xc8, 0xee, 0x4a, 0x95, 0x00, + 0x26, 0x9e, 0xe0, 0x12, 0x04, 0x52, + ], + [ + 0x9c, 0x18, 0x4d, 0x78, 0x78, 0x7d, 0x59, 0x46, 0x5e, 0xff, 0x7e, 0xaf, 0xeb, + 0x36, 0x66, 0xaa, 0x43, 0xf7, 0xe4, 0x74, 0x70, 0x45, 0x7e, 0x0a, 0x36, 0x45, + 0x2c, 0x91, 0xa2, 0xdd, 0x2a, 0xb0, 0xce, 0xb7, 0xe9, 0xb0, 0x90, 0x8d, 0xe2, + 0xa9, 0xf6, 0x3e, 0x2a, 0xce, 0x5f, 0xea, 0x9e, 0xc8, + ], + [ + 0x9b, 0xd3, 0x64, 0x59, 0xcb, 0x9f, 0xc4, 0xa6, 0x84, 0x76, 0x24, 0xf4, 0x44, + 0x05, 0xcf, 0x87, 0x7c, 0x5d, 0x74, 0x56, 0x27, 0xa1, 0xae, 0x64, 0x3d, 0x46, + 0xbc, 0xff, 0x0c, 0x23, 0x4f, 0xea, 0x46, 0xf6, 0xd4, 0x5f, 0xae, 0xbe, 0x6d, + 0x93, 0x3a, 0xa8, 0xd2, 0x2e, 0x73, 0x89, 0xa1, 0x82, 0x24, 0x7f, 0x60, 0x0f, + 0x7d, 0x34, 0x3e, 0xa5, 0xdc, 0x73, 0xb7, 0xa9, 0x7b, 0xd6, 0xca, 0xeb, + ] + ), + test_case!( + [ + 0xb8, 0x72, 0x0a, 0x4c, 0x3b, 0xaa, 0x7f, 0xc7, 0x5d, 0xc3, 0x2e, 0x7d, 0x11, + 0x76, 0x11, 0x92, 0x49, 0x08, 0xf1, 0x06, 0xeb, 0x9e, 0xf3, 0x0a, 0x0d, 0x5e, + 0x76, 0xbe, 0x97, 0x52, 0xf4, 0x8b, 0x95, 0x6a, 0x5c, 0xa1, 0x5b, 0x81, 0xe1, + 0x2b, 0xc7, 0x46, 0xa3, 0x17, 0x83, 0x0e, 0xa9, 0x67, 0x07, 0x56, 0xcc, 0x4f, + 0x35, 0xed, 0x8d, 0xcb, 0x0c, 0xb3, 0x07, 0xd1, 0x2f, 0x9e, 0x2c, 0x7f, 0x28, + ], + [ + 0x66, 0x61, 0xa3, 0xb9, 0xbd, 0x4c, 0xf1, 0xec, 0xb9, 0x74, 0x6d, 0x55, 0x7e, + 0x22, 0xdf, 0x8a, 0x86, 0x17, 0x0d, 0x19, + ], + [ + 0xec, 0x45, 0x1c, 0xdd, 0xbd, 0xc2, 0xe1, 0x27, 0x77, 0x7a, 0x42, 0x34, 0x72, + 0x2d, 0xed, 0xc4, 0xde, 0x93, 0x1d, 0x38, 0x45, 0x56, 0xf2, 0xc5, 0xc6, 0x07, + 0xb4, 0x01, 0xc7, 0x34, 0x73, 0xd3, + ], + [ + 0x85, 0xd5, 0xbc, 0x24, 0xff, 0x30, 0x5d, 0xa0, 0x2f, 0x7b, 0x52, 0x8a, 0x51, + 0xf5, 0x00, 0xe1, 0x92, 0xb7, 0xb7, 0xd3, 0x23, 0x2f, 0xb9, 0x8c, 0x16, 0x75, + 0xad, 0x1f, 0x90, 0xf9, 0x85, 0xbe, 0x3a, 0xad, 0x43, 0x28, 0xe9, 0x03, 0x7c, + 0x39, 0xed, 0x57, 0x6c, 0xb0, 0x1b, 0x97, 0xf5, 0x09, + ], + [ + 0x53, 0x6d, 0x5c, 0xd4, 0x19, 0x49, 0xa7, 0x26, 0x54, 0x05, 0xdd, 0x6d, 0x7e, + 0x7c, 0x35, 0xeb, 0x0c, 0xdd, 0xfd, 0xdc, 0x8c, 0xc1, 0x90, 0xdf, 0xf0, 0xb1, + 0xe5, 0x57, 0x59, 0xfb, 0x8f, 0x88, 0x4f, 0xb8, 0xe2, 0x4b, 0xf8, 0xe2, 0xc9, + 0xad, 0x2b, 0x4e, 0x24, 0x57, 0x13, 0xd9, 0xd5, 0x9b, 0x97, 0x82, 0xe2, 0x8e, + 0x0f, 0x35, 0x93, 0x61, 0xff, 0x2a, 0x0d, 0x10, 0xb9, 0x66, 0x56, 0x73, + ] + ), + test_case!( + [ + 0x0f, 0x15, 0x7f, 0x02, 0x2d, 0x99, 0xc3, 0x22, 0x4c, 0xac, 0xa9, 0xf5, 0xa5, + 0x21, 0x80, 0x50, 0x54, 0xc1, 0x37, 0x96, 0x46, 0xde, 0xda, 0x2e, 0x5d, 0xcf, + 0xcb, 0x29, 0x2f, 0xc3, 0x01, 0x2d, 0x88, 0x4a, 0xbf, 0xc1, 0xf0, 0xd7, 0x71, + 0x41, 0x18, 0x1d, 0xe5, 0x28, 0xba, 0x3c, 0x45, 0x8b, 0xd5, 0x83, 0x92, 0x1a, + 0xab, 0xd3, 0x62, 0x45, 0xd1, 0xb2, 0xd8, 0x57, 0x93, 0xac, 0x8d, 0x61, 0x7a, + 0xa0, + ], + [ + 0xe0, 0x88, 0xda, 0x90, 0x19, 0x76, 0x9d, 0xab, 0x80, 0xaa, 0x7e, 0x76, 0x10, + 0x37, 0x1a, 0x60, 0x23, 0x15, 0xa5, 0x7d, + ], + [ + 0xbf, 0x6e, 0x16, 0x4b, 0x81, 0x52, 0x5b, 0x39, 0xac, 0xeb, 0xda, 0x54, 0xdd, + 0x6a, 0xd6, 0xee, 0xb4, 0x52, 0x3e, 0xfd, 0x65, 0x3f, 0xfd, 0x2f, 0x8f, 0xcd, + 0x18, 0x2f, 0x61, 0xa9, 0xfe, 0x7a, + ], + [ + 0x8b, 0x0f, 0x73, 0x49, 0xa5, 0x7a, 0x8b, 0x6a, 0xae, 0x7e, 0xa1, 0xda, 0x63, + 0x10, 0x9c, 0xb5, 0x29, 0x5a, 0xd7, 0x34, 0xbf, 0x5e, 0x29, 0x46, 0x4d, 0x9c, + 0xd3, 0x5c, 0x62, 0x43, 0x7a, 0xa9, 0xd6, 0x85, 0xe7, 0x36, 0xc5, 0x51, 0x98, + 0xb1, 0x1f, 0xb4, 0xff, 0x28, 0xc3, 0x6a, 0xd6, 0x03, + ], + [ + 0x4f, 0xc9, 0x98, 0x80, 0x67, 0xc4, 0x33, 0x99, 0x5f, 0x59, 0xfe, 0xe7, 0xe3, + 0xf6, 0x6f, 0xbf, 0xb1, 0x5d, 0x38, 0x58, 0x16, 0xff, 0xa6, 0xd8, 0x98, 0x75, + 0xa0, 0xd0, 0x0c, 0x99, 0xdb, 0x4b, 0x40, 0x23, 0x13, 0x65, 0x33, 0x31, 0x9e, + 0x58, 0x95, 0xa5, 0x8d, 0x9e, 0x3d, 0x9a, 0x57, 0x82, 0x73, 0x96, 0x9f, 0x2c, + 0xf4, 0x29, 0x04, 0x5e, 0x44, 0xbf, 0xcf, 0x64, 0x5d, 0x8d, 0xf9, 0x99, + ] + ), + test_case!( + [ + 0x79, 0x51, 0xb5, 0x57, 0x9f, 0x24, 0x79, 0xaa, 0xeb, 0x62, 0xeb, 0xbb, 0x66, + 0xe9, 0x03, 0x96, 0x4c, 0x71, 0x32, 0xa4, 0x1b, 0x0b, 0x93, 0xca, 0x82, 0x12, + 0x75, 0x80, 0x62, 0x04, 0x64, 0x85, 0x35, 0x80, 0xe2, 0x0a, 0xb2, 0x6d, 0xbd, + 0xc0, 0x6c, 0xd3, 0x54, 0xc8, 0xc9, 0xc6, 0x66, 0x31, 0xa1, 0xc8, 0xb1, 0x0e, + 0x5f, 0xf9, 0x16, 0xe9, 0x0a, 0xec, 0xf9, 0x10, 0x94, 0xd7, 0x0e, 0xc5, 0x8e, + 0x9a, 0x02, + ], + [ + 0x74, 0x81, 0x61, 0x52, 0xc0, 0xeb, 0x65, 0x14, 0xbe, 0xba, 0x4f, 0x43, 0x3f, + 0x1f, 0x02, 0x36, 0x9b, 0xb5, 0x00, 0x4a, + ], + [ + 0xb4, 0xfd, 0xd8, 0xb5, 0x2f, 0x20, 0x82, 0x00, 0x20, 0xaf, 0x65, 0x20, 0xf0, + 0x6e, 0x17, 0x7c, 0x10, 0x3d, 0xe5, 0x2b, 0x68, 0x11, 0x87, 0x50, 0xb5, 0x26, + 0xbd, 0x60, 0x36, 0x85, 0xc8, 0xfb, + ], + [ + 0xfb, 0xb9, 0x59, 0x12, 0xb3, 0x72, 0x55, 0x4a, 0x95, 0xcf, 0x6a, 0x87, 0xdc, + 0x45, 0xa9, 0xa4, 0x03, 0x9b, 0x89, 0x6f, 0xf1, 0xe8, 0x62, 0x55, 0x39, 0x21, + 0x73, 0x6a, 0xfe, 0xd8, 0x1f, 0xf1, 0xd4, 0x6c, 0x90, 0x40, 0xaf, 0x1f, 0xca, + 0x75, 0xe7, 0xb3, 0x94, 0xe2, 0xe9, 0x1e, 0x0b, 0x47, + ], + [ + 0x0e, 0x4a, 0x98, 0x6e, 0x36, 0x17, 0x2a, 0x2a, 0x46, 0xdb, 0x50, 0x17, 0xef, + 0x56, 0xe2, 0x18, 0xdc, 0x4b, 0x98, 0x44, 0x7a, 0xae, 0x7f, 0x73, 0xf6, 0x4c, + 0x79, 0xa1, 0x21, 0x10, 0x97, 0x32, 0x16, 0xea, 0x9b, 0x1d, 0xd6, 0x15, 0x64, + 0xd3, 0x9c, 0xc9, 0xf7, 0xc9, 0x47, 0xfe, 0x61, 0xe7, 0x8b, 0xdf, 0x31, 0xb1, + 0x0c, 0x52, 0xb3, 0xc2, 0x93, 0x77, 0x51, 0x8e, 0x10, 0xe5, 0x2b, 0x9b, + ] + ), + test_case!( + [ + 0x59, 0x79, 0xfc, 0xb2, 0x37, 0x18, 0xfc, 0x85, 0xe5, 0x0f, 0x54, 0x46, 0xbc, + 0x64, 0x27, 0xed, 0xcb, 0xe2, 0x1b, 0x49, 0x58, 0x41, 0xee, 0x23, 0x63, 0x3f, + 0xc2, 0xe9, 0x19, 0xc8, 0x25, 0x8d, 0x23, 0x3b, 0x02, 0xb3, 0x34, 0xb8, 0x49, + 0xb8, 0xbb, 0xd1, 0xa2, 0x59, 0x77, 0x6c, 0x22, 0xc5, 0x2a, 0x64, 0xca, 0x2e, + 0xad, 0x48, 0x53, 0x03, 0x03, 0x1e, 0xe5, 0x29, 0x9d, 0x0e, 0xec, 0x36, 0x34, + 0x30, 0xf2, 0x95, + ], + [ + 0x21, 0x23, 0xbf, 0x94, 0x51, 0x7c, 0xdf, 0xa5, 0x97, 0x8c, 0x89, 0x7f, 0xbe, + 0xc7, 0xab, 0x99, 0x06, 0x08, 0xbf, 0xfa, + ], + [ + 0xb7, 0x92, 0xa5, 0xea, 0xda, 0xfb, 0x4e, 0x0c, 0x9b, 0x15, 0x6c, 0x7e, 0x75, + 0x72, 0x52, 0xca, 0xa7, 0xdf, 0xe1, 0x1b, 0x0d, 0xd7, 0x43, 0xe9, 0xd0, 0x75, + 0x19, 0xea, 0xac, 0x8f, 0x7d, 0x56, + ], + [ + 0x2c, 0xa2, 0x85, 0x3e, 0x3a, 0x52, 0xab, 0xe3, 0xdf, 0x87, 0x93, 0x85, 0xe8, + 0xbf, 0xad, 0x07, 0x48, 0x40, 0xfc, 0x1a, 0x11, 0x27, 0x1e, 0xed, 0xed, 0xad, + 0xd1, 0x6e, 0xa1, 0xd9, 0x5c, 0xb4, 0xa5, 0x85, 0x5f, 0xf7, 0x98, 0xf9, 0xc9, + 0xd8, 0x35, 0xbc, 0xd0, 0x91, 0x82, 0xa2, 0x3b, 0x10, + ], + [ + 0x94, 0xde, 0x58, 0x98, 0x46, 0x5a, 0xd7, 0x41, 0x2b, 0x37, 0x1b, 0x71, 0xa4, + 0x43, 0x97, 0x86, 0x4b, 0x1f, 0xa7, 0x65, 0x3c, 0x64, 0x2e, 0x2a, 0x44, 0xc7, + 0x77, 0x31, 0xdc, 0x6a, 0x72, 0xc2, 0xb1, 0x8b, 0x8f, 0xff, 0x29, 0xb6, 0x3e, + 0xb9, 0x11, 0x43, 0x3f, 0x56, 0x57, 0xa4, 0x0c, 0xc4, 0xd3, 0x24, 0x20, 0xd3, + 0x9c, 0xf1, 0x62, 0xf2, 0x19, 0x27, 0x93, 0x7a, 0xdb, 0x64, 0x30, 0x81, + ] + ), + test_case!( + [ + 0x79, 0xe5, 0x5f, 0x2e, 0x88, 0x2a, 0x37, 0xe6, 0xdf, 0xc8, 0x02, 0x07, 0x94, + 0x27, 0xd8, 0x7e, 0x46, 0xfc, 0xa4, 0x3e, 0x5d, 0x4d, 0x9a, 0xfc, 0x2f, 0xc5, + 0x8c, 0x80, 0xcc, 0xc9, 0x0b, 0x6e, 0xb2, 0x97, 0xbb, 0xbc, 0x55, 0xe7, 0x62, + 0x13, 0x23, 0x28, 0x4a, 0x88, 0xbe, 0x59, 0x7b, 0x31, 0x43, 0x90, 0xc6, 0xbb, + 0xc7, 0x20, 0x6c, 0x2b, 0x88, 0xb1, 0x4d, 0x1b, 0xd2, 0x22, 0x3d, 0x3e, 0xa9, + 0x23, 0xbf, 0xff, 0x19, + ], + [ + 0x59, 0x6d, 0xfd, 0x02, 0xf7, 0x77, 0x3f, 0x2c, 0x51, 0x95, 0xb2, 0xe9, 0x82, + 0xfc, 0x1e, 0x77, 0x56, 0x0b, 0x84, 0x35, + ], + [ + 0xd5, 0x83, 0xa5, 0x88, 0x90, 0x17, 0x48, 0x53, 0x42, 0x43, 0xd4, 0xfa, 0x7f, + 0xfe, 0x0e, 0x61, 0xac, 0xe5, 0x90, 0x84, 0xef, 0x97, 0x11, 0x16, 0x3d, 0x83, + 0xfd, 0x95, 0xa7, 0x4d, 0xf5, 0x1c, + ], + [ + 0x59, 0x48, 0x81, 0xcd, 0x61, 0x10, 0xae, 0x7b, 0x67, 0x60, 0x03, 0x3d, 0xd1, + 0x3e, 0x11, 0x56, 0xf6, 0x89, 0x19, 0x68, 0x7d, 0xc0, 0x99, 0xdf, 0x24, 0x17, + 0xe8, 0x25, 0x68, 0x44, 0x3d, 0x36, 0xca, 0x6e, 0x6d, 0x83, 0xb2, 0x2b, 0x33, + 0x54, 0x9a, 0x46, 0x31, 0x7c, 0x3a, 0xea, 0x7a, 0x0a, + ], + [ + 0x24, 0x2a, 0x04, 0x80, 0xbc, 0x00, 0xc8, 0x92, 0xf6, 0x73, 0x10, 0x28, 0x18, + 0xbf, 0xca, 0xe1, 0x54, 0xab, 0x5e, 0x4b, 0xff, 0x9a, 0x84, 0xdc, 0x56, 0x0d, + 0xb3, 0x69, 0xef, 0x3b, 0x5d, 0x9d, 0xf2, 0xba, 0x1e, 0x92, 0x2e, 0x29, 0xfe, + 0x9d, 0x65, 0xfb, 0xd8, 0xa0, 0x7b, 0x8e, 0xaa, 0x3d, 0x5b, 0x95, 0x82, 0xdb, + 0xa5, 0x1e, 0x99, 0x50, 0x24, 0x68, 0x4b, 0xed, 0xdc, 0xf6, 0x31, 0x35, + ] + ), + test_case!( + [ + 0xea, 0x15, 0xf8, 0xc4, 0x41, 0xd0, 0xba, 0xf1, 0x7c, 0x80, 0x0e, 0x0d, 0x5a, + 0x9d, 0xb4, 0x1b, 0x98, 0x24, 0x16, 0x45, 0x24, 0x5d, 0x7e, 0x5a, 0xc9, 0xd2, + 0xd8, 0xb7, 0x30, 0x8f, 0xc4, 0xdd, 0x89, 0xf8, 0xa8, 0x75, 0x4b, 0xfd, 0xc5, + 0x7b, 0x41, 0xb5, 0x50, 0xff, 0x08, 0xf2, 0x2a, 0x47, 0xef, 0x17, 0xa9, 0x9c, + 0xf7, 0x13, 0x0c, 0x73, 0xe5, 0xa8, 0x4d, 0xa0, 0xb1, 0x2d, 0x90, 0x4c, 0x44, + 0x09, 0xf9, 0x1c, 0xa5, 0x92, + ], + [ + 0xea, 0x4b, 0xf7, 0x90, 0x5c, 0xe9, 0xed, 0x8c, 0xcd, 0xae, 0x14, 0x26, 0x2d, + 0xc1, 0xa8, 0x99, 0xb3, 0x82, 0x02, 0x8f, + ], + [ + 0x57, 0x79, 0x6d, 0x31, 0x43, 0x87, 0xa9, 0xd7, 0x6b, 0xbe, 0x62, 0xf9, 0xa4, + 0xb2, 0x1f, 0x60, 0xd7, 0x20, 0xdc, 0x17, 0x72, 0x75, 0x66, 0x4f, 0xbb, 0x9f, + 0x30, 0xb5, 0x38, 0x3c, 0x7f, 0x8c, + ], + [ + 0x2a, 0x2f, 0x1e, 0x3e, 0x00, 0xe1, 0x61, 0xd9, 0xbd, 0xf0, 0x02, 0x50, 0xa1, + 0xe9, 0x42, 0x97, 0x4e, 0xfd, 0x32, 0x99, 0xc2, 0xf3, 0x28, 0x39, 0x4c, 0x0a, + 0xe5, 0x8d, 0x30, 0xdd, 0x39, 0x9b, 0xd6, 0x97, 0x2e, 0x9e, 0xdb, 0x88, 0x85, + 0x1b, 0xff, 0xb1, 0x80, 0x80, 0x2e, 0xda, 0x34, 0x10, + ], + [ + 0xd3, 0x68, 0x52, 0xa7, 0xfc, 0x77, 0x64, 0x93, 0xa4, 0x8f, 0x48, 0x18, 0xc9, + 0x76, 0x01, 0x4a, 0xaa, 0x6f, 0x99, 0x8a, 0xad, 0x02, 0xf0, 0x62, 0x9a, 0xfc, + 0xa2, 0x31, 0xdf, 0x7d, 0x2d, 0x27, 0x10, 0x42, 0xc4, 0x97, 0x6e, 0x96, 0x0b, + 0x01, 0x67, 0xaf, 0x41, 0x44, 0x3d, 0x4d, 0xd6, 0xb4, 0xdd, 0x43, 0xcc, 0xa1, + 0xc5, 0x15, 0x83, 0x95, 0x41, 0x24, 0x27, 0x13, 0xb3, 0xf1, 0x76, 0x7b, + ] + ), + test_case!( + [ + 0x27, 0xf0, 0x30, 0x3a, 0x41, 0x0f, 0xaa, 0xf8, 0x1c, 0x0f, 0xb9, 0x2d, 0x1d, + 0x76, 0x02, 0x23, 0x2c, 0x1c, 0x98, 0x97, 0xb2, 0x44, 0xef, 0xb7, 0xd6, 0x24, + 0xd2, 0xfb, 0x39, 0x7e, 0xfd, 0x12, 0x4f, 0x63, 0x3a, 0x40, 0xd9, 0x24, 0x35, + 0x7e, 0x52, 0x33, 0x93, 0x82, 0xa0, 0x3d, 0x79, 0xc9, 0xea, 0x06, 0x8c, 0x05, + 0xab, 0x0d, 0xc7, 0x16, 0xc2, 0x81, 0x4f, 0x54, 0xe5, 0x6b, 0xda, 0x81, 0x2e, + 0xc5, 0xfd, 0xe9, 0x1a, 0x4c, 0x06, + ], + [ + 0x50, 0xad, 0x70, 0xee, 0x51, 0xde, 0xcd, 0x6c, 0xdf, 0xa5, 0x8c, 0xcf, 0x28, + 0xb6, 0x49, 0xfc, 0xf5, 0x0c, 0xca, 0xa5, + ], + [ + 0x9e, 0x9e, 0xb0, 0xe5, 0xa2, 0x66, 0x86, 0x99, 0x8e, 0x09, 0x88, 0xb3, 0xf0, + 0x83, 0x36, 0x81, 0xf8, 0xd3, 0x42, 0xe8, 0xbc, 0xc0, 0x26, 0x4b, 0x7b, 0xd5, + 0xe0, 0x54, 0x9f, 0x6f, 0x8b, 0xe2, + ], + [ + 0x59, 0x45, 0xc0, 0xa3, 0x45, 0x64, 0x92, 0xc6, 0x7d, 0x3e, 0x21, 0xce, 0x7c, + 0x05, 0x80, 0xc9, 0xa2, 0x55, 0x2e, 0x80, 0x82, 0x35, 0x2f, 0x6f, 0xc1, 0x9c, + 0xb0, 0xba, 0x78, 0xd6, 0xd9, 0xe9, 0x84, 0x1a, 0x52, 0xc1, 0xa3, 0xe8, 0xf9, + 0x2d, 0xcc, 0x20, 0x9f, 0x5e, 0xe1, 0x23, 0xb5, 0xc0, + ], + [ + 0x29, 0x5f, 0xa2, 0xa1, 0x6d, 0x08, 0xdd, 0xac, 0xe1, 0x64, 0x8b, 0x75, 0x79, + 0x6d, 0x3a, 0x33, 0x8f, 0xff, 0xd3, 0x22, 0x98, 0xd1, 0xf2, 0xcb, 0xc6, 0x35, + 0x30, 0xe1, 0x22, 0xd2, 0xb9, 0x77, 0x0c, 0x01, 0x50, 0x4c, 0x86, 0x0a, 0x36, + 0x85, 0x94, 0xb1, 0x60, 0x38, 0xf6, 0x74, 0x4b, 0x98, 0xff, 0xc8, 0x89, 0x31, + 0xb2, 0x50, 0x3d, 0x26, 0xed, 0x47, 0x05, 0xa5, 0xf1, 0xb8, 0xdf, 0x7f, + ] + ), + test_case!( + [ + 0xd1, 0x00, 0x9f, 0x11, 0x7e, 0xaf, 0x68, 0x58, 0x33, 0xdd, 0x3b, 0x32, 0x0a, + 0xfb, 0x79, 0xed, 0x14, 0x78, 0xa9, 0x79, 0xe0, 0xfd, 0x49, 0x41, 0x67, 0xe1, + 0x8d, 0x7a, 0x0e, 0xcb, 0x8b, 0xc2, 0xd6, 0xa9, 0xfc, 0xd6, 0x7d, 0xbf, 0x62, + 0x34, 0xe6, 0x30, 0x55, 0xb7, 0xda, 0xf1, 0x06, 0x9c, 0x5a, 0x78, 0xa5, 0x2e, + 0xdb, 0xf0, 0x9d, 0x92, 0xd3, 0xa1, 0x85, 0x1d, 0x35, 0xf0, 0x38, 0xd9, 0x65, + 0x1e, 0x87, 0x78, 0xd9, 0x07, 0x14, 0x70, + ], + [ + 0xfd, 0x57, 0xd5, 0xd3, 0x5d, 0x77, 0xcd, 0x32, 0x1b, 0x04, 0xab, 0xd3, 0x1a, + 0xb0, 0x9a, 0xed, 0x52, 0xe3, 0x88, 0x56, + ], + [ + 0x24, 0x26, 0x23, 0xa6, 0x2e, 0xb2, 0x68, 0x6f, 0x7d, 0x5f, 0xc0, 0x46, 0x65, + 0x73, 0xe7, 0x59, 0x1c, 0xfc, 0xec, 0x41, 0xc8, 0x79, 0x05, 0x92, 0xf9, 0x17, + 0xb2, 0xc1, 0xd2, 0xee, 0xd6, 0xa2, + ], + [ + 0xd1, 0xdc, 0x32, 0x55, 0x1a, 0xe0, 0xf3, 0x74, 0x74, 0x0f, 0x4f, 0x16, 0xdc, + 0x3d, 0xf1, 0xeb, 0x85, 0x58, 0x8c, 0xa6, 0x18, 0x82, 0x00, 0xb3, 0xa6, 0x6b, + 0x20, 0xd8, 0x01, 0x65, 0x81, 0xa2, 0xb7, 0x81, 0x13, 0x34, 0x0d, 0x54, 0xb1, + 0x91, 0xf9, 0x29, 0x17, 0xe7, 0x99, 0x46, 0xab, 0xd0, + ], + [ + 0x04, 0x9f, 0x32, 0x34, 0x1a, 0xff, 0x82, 0x14, 0x63, 0xf7, 0x4f, 0x86, 0x63, + 0xd7, 0xca, 0xad, 0xe7, 0x77, 0x60, 0x4f, 0xb4, 0x22, 0xe4, 0x9a, 0xba, 0x07, + 0xa7, 0x03, 0x3d, 0x30, 0xd1, 0x9e, 0xcc, 0x05, 0x3e, 0x0d, 0x32, 0xd6, 0xb6, + 0xdc, 0x35, 0xc7, 0x6d, 0xd3, 0x9e, 0x8d, 0xb2, 0x90, 0x3a, 0xe1, 0xf3, 0x9a, + 0x57, 0xd2, 0x85, 0x1f, 0xd4, 0xab, 0x01, 0x03, 0xe3, 0xa0, 0x81, 0x39, + ] + ), + test_case!( + [ + 0x19, 0x5a, 0xf7, 0xd9, 0xa3, 0x3b, 0x42, 0x6d, 0x16, 0xaa, 0x36, 0x33, 0x18, + 0x91, 0x5c, 0xe3, 0x13, 0x7b, 0x12, 0xa9, 0x46, 0x12, 0x2e, 0x85, 0x5c, 0x89, + 0xdf, 0xde, 0x67, 0xde, 0xe8, 0x16, 0xa2, 0x8d, 0x05, 0x5f, 0xcb, 0x56, 0x69, + 0x68, 0xb3, 0xd7, 0x54, 0xc4, 0x22, 0xf9, 0x8e, 0x3b, 0x5b, 0xea, 0x8f, 0xfe, + 0x73, 0x1d, 0x83, 0x77, 0xc8, 0xc0, 0x27, 0x7d, 0x04, 0xfd, 0x4d, 0x0a, 0x4a, + 0xb7, 0xfe, 0xa6, 0x00, 0x66, 0xf4, 0x9a, 0xd3, + ], + [ + 0xce, 0xf5, 0xb7, 0xa3, 0xa5, 0xc1, 0xfe, 0xa4, 0x79, 0xbb, 0xf9, 0x56, 0x39, + 0xed, 0x02, 0x93, 0xe0, 0x15, 0x64, 0x64, + ], + [ + 0xe0, 0x14, 0xd9, 0xd7, 0xa1, 0xc2, 0x23, 0x96, 0xa5, 0xf9, 0xb0, 0x28, 0xb5, + 0x67, 0xc1, 0x5d, 0xe0, 0x89, 0x76, 0x36, 0x0b, 0x6c, 0x63, 0x8a, 0xc4, 0xca, + 0x76, 0xb3, 0x16, 0xb5, 0xa7, 0x25, + ], + [ + 0x4c, 0x58, 0xfd, 0x63, 0x23, 0x52, 0x75, 0xcb, 0x66, 0x2f, 0xdb, 0xff, 0x73, + 0x0e, 0x54, 0x8c, 0xaf, 0x2e, 0x35, 0x6a, 0xd9, 0xf6, 0x16, 0x39, 0xfe, 0x81, + 0x09, 0x08, 0x3c, 0x68, 0x96, 0x1b, 0x84, 0x0b, 0xb7, 0x9f, 0x06, 0x61, 0xa9, + 0x87, 0x80, 0xec, 0x14, 0xd4, 0xee, 0x78, 0x05, 0x55, + ], + [ + 0xc7, 0x17, 0x5c, 0x64, 0x8e, 0x4b, 0x28, 0xe1, 0xb3, 0x9a, 0xab, 0xe0, 0xd0, + 0x5d, 0xed, 0x99, 0x3f, 0xa3, 0xe5, 0x6b, 0x93, 0x25, 0x37, 0x81, 0xac, 0x7d, + 0x33, 0x0b, 0x33, 0xe2, 0xe3, 0x62, 0xc5, 0x14, 0x11, 0xee, 0x02, 0x71, 0x11, + 0xe4, 0x3c, 0x52, 0x42, 0xa0, 0xb6, 0xa9, 0x63, 0x58, 0xfc, 0xef, 0x37, 0x94, + 0x9b, 0x4c, 0xf8, 0xe1, 0x40, 0x28, 0x2f, 0x9e, 0xa7, 0x1e, 0x84, 0x3f, + ] + ), + test_case!( + [ + 0x81, 0x5e, 0xe5, 0x67, 0x65, 0x1b, 0x25, 0x7b, 0x71, 0x3b, 0xc7, 0xb7, 0xe1, + 0xec, 0x8a, 0x69, 0x08, 0x79, 0x11, 0x59, 0x9d, 0xdf, 0x12, 0xf4, 0x0e, 0x27, + 0x7e, 0x73, 0x25, 0x8c, 0x61, 0xde, 0x3a, 0xfe, 0xaf, 0xa7, 0x62, 0xc9, 0x02, + 0x18, 0x3b, 0x85, 0x2f, 0x9f, 0xf0, 0xe6, 0x0a, 0x81, 0xd2, 0x59, 0x07, 0x78, + 0xfe, 0x7a, 0x8b, 0x4e, 0x4a, 0x7a, 0xec, 0xb9, 0x05, 0x84, 0xbb, 0x14, 0xfb, + 0x13, 0x5b, 0xfc, 0xf7, 0xb0, 0x6d, 0xb7, 0x68, 0x5d, + ], + [ + 0xf1, 0xa1, 0x0a, 0x51, 0x2b, 0xa7, 0xdf, 0x1a, 0x35, 0x77, 0x31, 0x28, 0x10, + 0x07, 0xa5, 0x7d, 0x64, 0x82, 0x91, 0x45, + ], + [ + 0x8d, 0x66, 0x60, 0x7e, 0xfe, 0x75, 0x63, 0x3e, 0x3b, 0xdb, 0xec, 0x42, 0x08, + 0xec, 0xdc, 0x93, 0x88, 0xb4, 0x64, 0xb4, 0xf1, 0x60, 0x14, 0x41, 0x01, 0x17, + 0x4b, 0x9b, 0x5e, 0x70, 0xc0, 0xae, + ], + [ + 0x2e, 0xab, 0xbb, 0x49, 0x93, 0x2c, 0xee, 0x76, 0xbf, 0x1c, 0x71, 0x63, 0x48, + 0x89, 0xa8, 0xd2, 0xc9, 0xdc, 0xd6, 0x13, 0xe8, 0xde, 0x28, 0xfc, 0xce, 0x2e, + 0x01, 0xf2, 0x1f, 0x08, 0xdf, 0x17, 0x97, 0x94, 0xfd, 0x38, 0x92, 0xc5, 0x19, + 0x48, 0x77, 0xb7, 0xec, 0xf2, 0x9d, 0x1c, 0x27, 0xf5, + ], + [ + 0x5f, 0x96, 0xcc, 0x97, 0x45, 0x83, 0xe1, 0xa2, 0xcc, 0xcf, 0x63, 0xa4, 0x2f, + 0x9a, 0x0d, 0x75, 0x04, 0xb2, 0xa6, 0xd8, 0x27, 0x36, 0xd8, 0x7e, 0x65, 0x2e, + 0x22, 0x76, 0x69, 0x20, 0x78, 0x9e, 0x7f, 0x4b, 0xeb, 0xae, 0x7f, 0x8f, 0xb3, + 0x13, 0xe0, 0x67, 0xd4, 0xc5, 0xef, 0xd2, 0x8d, 0x6c, 0x7a, 0xbe, 0xb7, 0xb4, + 0xf3, 0x66, 0xd6, 0xbd, 0xcb, 0xd1, 0x6d, 0x6b, 0x0e, 0x4b, 0x75, 0xaa, + ] + ), + test_case!( + [ + 0x8e, 0x8a, 0x55, 0x1f, 0xb8, 0x66, 0xe1, 0x18, 0xc4, 0x92, 0x47, 0x5c, 0x41, + 0x80, 0x21, 0xa4, 0xc9, 0xf7, 0x13, 0x14, 0x61, 0x26, 0xf2, 0x8d, 0x7f, 0xf6, + 0x08, 0x49, 0x4c, 0x8e, 0xb2, 0x2c, 0x60, 0x99, 0x0c, 0xaf, 0x08, 0xf6, 0xbc, + 0xdf, 0xf0, 0x64, 0x99, 0x17, 0xda, 0x50, 0x0b, 0x00, 0xca, 0x15, 0x57, 0xe6, + 0x78, 0x1b, 0x6a, 0x40, 0x0d, 0x84, 0x88, 0xc5, 0x5c, 0x91, 0xa5, 0x86, 0x71, + 0x9c, 0x3d, 0x96, 0x67, 0xf4, 0x00, 0x41, 0x50, 0xea, 0x62, + ], + [ + 0x06, 0x2a, 0x05, 0x5b, 0x5f, 0x3f, 0x45, 0xd5, 0x80, 0x1b, 0xfa, 0xcc, 0xd1, + 0x0c, 0x3d, 0x24, 0xf0, 0x6c, 0x33, 0xb2, + ], + [ + 0xce, 0xf0, 0x26, 0xf3, 0xe2, 0x46, 0x6e, 0x18, 0xe2, 0xab, 0x50, 0x2f, 0x08, + 0x61, 0x7c, 0xb4, 0x9e, 0x10, 0x0a, 0xb4, 0x93, 0xe0, 0x60, 0xa2, 0x01, 0xe7, + 0xf1, 0xc8, 0x68, 0xf2, 0xde, 0xf4, + ], + [ + 0x16, 0x3c, 0xaa, 0xe5, 0x7d, 0x1a, 0xdb, 0xdf, 0xc8, 0xad, 0xd9, 0x83, 0x2a, + 0x1f, 0x00, 0x8a, 0x28, 0x17, 0xf0, 0x2d, 0x49, 0x73, 0x21, 0xf3, 0x5b, 0x90, + 0x8b, 0xee, 0x0b, 0xcc, 0x97, 0x5e, 0x73, 0xc5, 0x50, 0x07, 0x6e, 0x79, 0x3b, + 0x0b, 0xad, 0xd3, 0x8c, 0x84, 0xa9, 0x24, 0xea, 0xe2, + ], + [ + 0x4b, 0x4c, 0xd1, 0x1a, 0x19, 0x49, 0x9d, 0xb0, 0x2a, 0x81, 0x6c, 0x5c, 0xcf, + 0xa8, 0x20, 0xd4, 0x39, 0x75, 0x8b, 0xe4, 0xe8, 0xfd, 0x49, 0x43, 0x8a, 0x65, + 0x50, 0xb9, 0xa8, 0x0f, 0xd1, 0xb9, 0xde, 0x2c, 0x6a, 0x83, 0x2d, 0x29, 0x8b, + 0x54, 0xea, 0xc0, 0xb2, 0x83, 0x85, 0x84, 0x67, 0x7f, 0xe7, 0x93, 0x9f, 0xc2, + 0x43, 0x23, 0x63, 0x78, 0xf3, 0xc9, 0x3c, 0x40, 0x90, 0xad, 0xff, 0xa2, + ] + ), + test_case!( + [ + 0x34, 0x4b, 0xff, 0x4b, 0x2c, 0x8d, 0x1d, 0x4e, 0xff, 0x62, 0xbd, 0xa1, 0x3d, + 0xac, 0x35, 0x6f, 0xb8, 0xd9, 0x77, 0x0e, 0x19, 0x00, 0x31, 0x66, 0x24, 0xaf, + 0x19, 0x51, 0xa8, 0x63, 0xaf, 0xff, 0x4b, 0x34, 0x55, 0x6b, 0x2f, 0x8d, 0x60, + 0x72, 0xcc, 0xc9, 0x56, 0x24, 0x82, 0x86, 0xe3, 0xac, 0xe5, 0x78, 0x46, 0xdd, + 0x80, 0x07, 0x74, 0xe1, 0x76, 0x26, 0xb5, 0x37, 0x9b, 0xe8, 0x8c, 0x78, 0xe2, + 0x34, 0x90, 0x6f, 0x47, 0x98, 0x16, 0x6f, 0xee, 0x9d, 0x67, 0x28, + ], + [ + 0x67, 0x40, 0x33, 0x76, 0xfd, 0x7c, 0xee, 0xb6, 0xdf, 0x90, 0x4e, 0xe0, 0xcd, + 0xca, 0x0c, 0xb7, 0xf9, 0x8b, 0x98, 0xd1, + ], + [ + 0xab, 0xdc, 0x9c, 0xfd, 0xb0, 0x9a, 0xb0, 0xf8, 0x3c, 0xae, 0x37, 0x52, 0xae, + 0x67, 0x11, 0xfc, 0x3c, 0xcc, 0x45, 0x25, 0x5b, 0x92, 0x05, 0x7e, 0xc7, 0x4a, + 0x8f, 0x11, 0xd9, 0x48, 0xa1, 0x4f, + ], + [ + 0xed, 0x7b, 0x7b, 0x62, 0xe6, 0x5e, 0x02, 0x22, 0xbc, 0xb8, 0x1f, 0xe9, 0x71, + 0x15, 0x9d, 0x7b, 0x29, 0xc7, 0x24, 0xf8, 0xfd, 0xc0, 0x8c, 0xb2, 0xdd, 0x67, + 0x56, 0x02, 0x01, 0xfe, 0xba, 0xc2, 0xc9, 0xdb, 0x2e, 0xf5, 0xf2, 0xcb, 0x0b, + 0x8d, 0xe8, 0x4b, 0x31, 0x82, 0x2e, 0x00, 0x12, 0x14, + ], + [ + 0xfa, 0xca, 0xb8, 0x26, 0x2c, 0x41, 0x60, 0x1f, 0xf5, 0xa6, 0xef, 0x53, 0x53, + 0xdf, 0xb2, 0xa5, 0x19, 0xcb, 0xa3, 0x13, 0xfa, 0x65, 0x53, 0x26, 0x43, 0x73, + 0xdc, 0x7d, 0xbc, 0x2f, 0xd7, 0x3b, 0xb1, 0xac, 0xb5, 0x85, 0x0d, 0x5c, 0x1a, + 0x6f, 0x53, 0xe5, 0x44, 0xbb, 0xc5, 0x68, 0xa5, 0xd5, 0xdc, 0xb8, 0xa8, 0xff, + 0xff, 0x5e, 0x2f, 0x75, 0xa6, 0xdf, 0x4b, 0xcc, 0xbb, 0xfa, 0xa4, 0x9d, + ] + ), + test_case!( + [ + 0xf5, 0xc5, 0x46, 0xed, 0x3e, 0x48, 0x33, 0xac, 0x25, 0x5b, 0x22, 0x6f, 0xfb, + 0x06, 0x0d, 0xc6, 0xa5, 0x92, 0xbc, 0x36, 0x0d, 0xb5, 0x74, 0x5a, 0x76, 0xe9, + 0x07, 0x17, 0xd9, 0x4d, 0xbd, 0xe3, 0x96, 0x95, 0xb0, 0x82, 0x6c, 0x20, 0x1a, + 0x14, 0x69, 0x6c, 0x6a, 0x63, 0x4b, 0x1b, 0x01, 0x11, 0xf1, 0x16, 0x80, 0xe5, + 0x61, 0xc5, 0x6a, 0x61, 0x2a, 0x66, 0x37, 0x78, 0x81, 0x10, 0x90, 0x07, 0x92, + 0x20, 0x4e, 0xe0, 0xc7, 0x82, 0x90, 0x19, 0x43, 0x4b, 0xa8, 0x47, 0x59, + ], + [ + 0x58, 0x95, 0xf1, 0x4c, 0x60, 0xed, 0x9f, 0xa5, 0xdf, 0xd7, 0xe6, 0x70, 0x96, + 0xa1, 0x8f, 0xce, 0xac, 0x01, 0xba, 0x84, + ], + [ + 0x20, 0xf6, 0xec, 0x97, 0x7f, 0xeb, 0xa3, 0xf6, 0x8a, 0x0e, 0x55, 0x7d, 0x62, + 0x25, 0xa2, 0x4a, 0x46, 0x0b, 0xb3, 0x1a, 0x70, 0xb0, 0x3e, 0x37, 0xab, 0x72, + 0x89, 0xd7, 0xfb, 0x92, 0xc4, 0x21, + ], + [ + 0x3f, 0x96, 0x8a, 0x68, 0x04, 0x88, 0xc7, 0xcb, 0x61, 0xb6, 0xa1, 0x95, 0x88, + 0x42, 0xe4, 0xcf, 0x63, 0x81, 0xc2, 0xba, 0xcc, 0xb5, 0x4d, 0x75, 0xd0, 0x98, + 0x9d, 0x14, 0x00, 0x91, 0x1d, 0xd5, 0xbb, 0x92, 0x5d, 0x07, 0x26, 0x86, 0x46, + 0x92, 0x07, 0x2b, 0x60, 0xdf, 0x32, 0x74, 0xd3, 0x4d, + ], + [ + 0x0a, 0x40, 0x1a, 0xcc, 0x66, 0xfa, 0x0e, 0x2c, 0xde, 0xc5, 0xf4, 0xbc, 0xc3, + 0x29, 0x3a, 0x7a, 0xbb, 0x66, 0xb2, 0x02, 0x6c, 0xfd, 0x8e, 0xa2, 0xd6, 0x05, + 0x05, 0x38, 0x6e, 0x01, 0xc1, 0x40, 0x91, 0x04, 0x5d, 0x72, 0xe0, 0x10, 0x0b, + 0xaf, 0xc1, 0x2b, 0x19, 0xf1, 0xd9, 0xf8, 0x2c, 0x5b, 0x5a, 0x82, 0x07, 0xb4, + 0xa6, 0xa8, 0x1f, 0xf2, 0x4e, 0xf0, 0xe2, 0xfd, 0xeb, 0x63, 0xd7, 0x4d, + ] + ), + test_case!( + [ + 0xd1, 0x1a, 0x65, 0xad, 0xe6, 0x8d, 0x31, 0x48, 0x3e, 0x7f, 0x6d, 0x8d, 0x87, + 0x35, 0x49, 0x0b, 0xb1, 0x0a, 0x4e, 0x39, 0x76, 0xdd, 0x7b, 0xe6, 0xf5, 0xb2, + 0xe7, 0x9a, 0x0e, 0x51, 0x77, 0xcc, 0xd5, 0x5c, 0x14, 0x83, 0x43, 0x49, 0x8a, + 0x06, 0xe4, 0x0d, 0xb1, 0xd0, 0x7e, 0x7b, 0x2e, 0x3b, 0x88, 0x90, 0x82, 0x4a, + 0x75, 0xad, 0xf3, 0x3d, 0x66, 0xb2, 0x11, 0xaa, 0x65, 0x24, 0xa0, 0x6e, 0x5c, + 0x84, 0x86, 0xd3, 0xd6, 0x46, 0xa1, 0x25, 0x56, 0xbf, 0x3e, 0x56, 0x7e, 0x09, + ], + [ + 0xab, 0x59, 0xc9, 0x55, 0xe8, 0x24, 0x7c, 0x14, 0x73, 0xc3, 0xdb, 0x41, 0x5f, + 0x3f, 0x39, 0x08, 0x9f, 0x3f, 0x41, 0x1f, + ], + [ + 0x3e, 0x72, 0xb2, 0x1b, 0x4e, 0x57, 0x95, 0x32, 0x91, 0x84, 0x0d, 0x67, 0xca, + 0xec, 0x66, 0xa2, 0x8b, 0x2a, 0x10, 0x88, 0x1b, 0xf0, 0x7d, 0x8d, 0xb0, 0xbd, + 0x80, 0xfc, 0x87, 0x55, 0xde, 0x94, + ], + [ + 0x64, 0x6d, 0xc1, 0x8a, 0xf3, 0x64, 0x3a, 0x6a, 0x72, 0xd4, 0xfc, 0x2f, 0x09, + 0x56, 0x46, 0xdd, 0x01, 0xf4, 0xff, 0xd5, 0xda, 0xcc, 0x4b, 0x61, 0xbc, 0xd7, + 0xd1, 0x99, 0x18, 0x18, 0x4b, 0xde, 0x4a, 0xba, 0x46, 0x57, 0x6c, 0xae, 0x47, + 0xf8, 0x37, 0xe4, 0x0b, 0x91, 0x84, 0x06, 0x63, 0xba, + ], + [ + 0x5f, 0x1f, 0x57, 0x75, 0xd4, 0x90, 0x73, 0x4b, 0x3b, 0xe3, 0x10, 0x17, 0x11, + 0x5f, 0x19, 0xab, 0xb7, 0xbb, 0xe7, 0x31, 0x1b, 0x87, 0x68, 0x57, 0xa2, 0x35, + 0x22, 0x30, 0x4b, 0xb4, 0x1e, 0x1d, 0x5b, 0x0d, 0x7e, 0x3c, 0xe2, 0x07, 0xb3, + 0x34, 0xfb, 0x10, 0x1c, 0x35, 0x41, 0xd9, 0xb6, 0xb9, 0x09, 0x44, 0x8c, 0xc5, + 0xb6, 0xc6, 0x1b, 0xbc, 0xc6, 0x5b, 0xba, 0x0d, 0xcb, 0x2a, 0x93, 0x20, + ] + ), + test_case!( + [ + 0x9a, 0xe8, 0xad, 0x90, 0x0f, 0x8b, 0x6d, 0x6b, 0x02, 0x6e, 0xba, 0xbb, 0x8e, + 0x70, 0xb0, 0xf9, 0x02, 0xc6, 0x2c, 0xbb, 0x5d, 0x64, 0x5f, 0xf5, 0x80, 0x3e, + 0x47, 0x03, 0x86, 0x56, 0xf1, 0xb7, 0x6d, 0x19, 0x63, 0x61, 0xa8, 0x6d, 0x1b, + 0x92, 0x6a, 0x37, 0x23, 0x37, 0x46, 0x95, 0x5a, 0x07, 0xd3, 0x9a, 0xea, 0xb6, + 0xf2, 0x7e, 0xfa, 0x83, 0x85, 0xce, 0x02, 0xc5, 0x68, 0xa6, 0x7a, 0x8d, 0x8f, + 0x6e, 0xad, 0x65, 0xfb, 0x4a, 0x8d, 0xb0, 0xfa, 0x2f, 0xa6, 0x2b, 0x11, 0x0a, + 0xc2, + ], + [ + 0xea, 0x99, 0x45, 0x31, 0x10, 0x5b, 0x52, 0x8f, 0x96, 0x0d, 0x57, 0x60, 0xe8, + 0x91, 0xb8, 0x4a, 0xcd, 0x4b, 0x0c, 0xbb, + ], + [ + 0x62, 0x8f, 0x92, 0x62, 0x6d, 0x33, 0x04, 0x5d, 0xcc, 0x57, 0x4b, 0x45, 0xe9, + 0x6b, 0xc1, 0x5f, 0x06, 0x02, 0x63, 0x1f, 0x82, 0x8d, 0x05, 0xe5, 0xb1, 0x5d, + 0x80, 0xca, 0x01, 0xcf, 0xb1, 0x6e, + ], + [ + 0x2f, 0x59, 0x79, 0xb7, 0x5d, 0x33, 0xdb, 0xbe, 0x68, 0xa3, 0x21, 0x1a, 0xc3, + 0xc2, 0x59, 0xfa, 0x2d, 0xef, 0x5e, 0xb7, 0xd8, 0x79, 0x10, 0x65, 0x75, 0x2e, + 0xa0, 0x4e, 0x07, 0x72, 0x18, 0xd1, 0xcf, 0x5c, 0x8f, 0x05, 0x46, 0x88, 0xd5, + 0x01, 0x1d, 0xc2, 0xcc, 0x20, 0x8f, 0xae, 0xbc, 0x7b, + ], + [ + 0xec, 0xd5, 0x82, 0x7b, 0x54, 0xe1, 0x7e, 0x1e, 0x57, 0xb4, 0x8f, 0xda, 0x3d, + 0xf5, 0x93, 0x19, 0x26, 0x90, 0x46, 0x0d, 0x0a, 0x1f, 0x88, 0xb6, 0x1c, 0x10, + 0x00, 0xda, 0x92, 0xb7, 0x25, 0x9f, 0xb2, 0x0c, 0x24, 0x1d, 0x20, 0x40, 0xa4, + 0xd2, 0x2c, 0x2f, 0xde, 0xcc, 0xf7, 0x96, 0xeb, 0x4c, 0xa9, 0xb4, 0x0f, 0x0d, + 0x85, 0x4c, 0x0e, 0x85, 0x40, 0xa8, 0xe7, 0x97, 0x4e, 0x25, 0x1b, 0x51, + ] + ), + test_case!( + [ + 0x62, 0xb9, 0x4b, 0xb4, 0xad, 0x2a, 0x5e, 0xfd, 0x4c, 0x26, 0x67, 0x36, 0x65, + 0xaf, 0xb6, 0xe6, 0x6d, 0x57, 0x83, 0x97, 0xcd, 0x18, 0x72, 0x63, 0x69, 0x8c, + 0x54, 0x1c, 0x35, 0xca, 0x7c, 0x61, 0xcf, 0x02, 0x8b, 0x45, 0x60, 0x18, 0xa1, + 0x22, 0xf9, 0xda, 0xb6, 0xde, 0xe2, 0x76, 0x98, 0x2a, 0x32, 0x78, 0x12, 0x3d, + 0xc1, 0xc0, 0x17, 0x84, 0xc1, 0x38, 0x88, 0x62, 0xdb, 0x91, 0x87, 0x9a, 0x38, + 0xbb, 0x64, 0x1c, 0xa2, 0x71, 0x46, 0x88, 0x58, 0xab, 0x88, 0x1d, 0x2d, 0xb6, + 0x2b, 0x17, + ], + [ + 0xdc, 0x05, 0x68, 0x3e, 0x45, 0x94, 0x7c, 0x42, 0xac, 0x44, 0x29, 0xdf, 0x8d, + 0xfa, 0xf3, 0xfc, 0xb7, 0x77, 0xcd, 0x7d, + ], + [ + 0x39, 0x14, 0xbf, 0xb1, 0x38, 0x82, 0xcd, 0x16, 0x8a, 0x27, 0x9c, 0x83, 0x7f, + 0x5f, 0x97, 0x1a, 0xcb, 0x79, 0x20, 0x9e, 0xb4, 0x63, 0xd0, 0x66, 0x39, 0x13, + 0x60, 0x2f, 0x38, 0xe4, 0x69, 0x5e, + ], + [ + 0xa6, 0x52, 0xa9, 0x0f, 0xf4, 0x02, 0x27, 0x62, 0x44, 0xde, 0x4e, 0x3d, 0x87, + 0xb8, 0x36, 0x19, 0x23, 0xde, 0xa0, 0xd6, 0x92, 0xaf, 0x8d, 0x90, 0x92, 0x92, + 0x5a, 0xbb, 0x4b, 0x5f, 0x87, 0xad, 0xe7, 0xe2, 0xc0, 0x8f, 0xe8, 0x2c, 0x64, + 0xf9, 0xc2, 0xa9, 0x7f, 0x1b, 0xe8, 0x54, 0x4e, 0x5d, + ], + [ + 0xa8, 0x5a, 0xbb, 0xb4, 0xdb, 0x9a, 0x79, 0xb7, 0xb0, 0x7a, 0x78, 0x01, 0x00, + 0x31, 0x4b, 0x25, 0xb0, 0x5b, 0xe5, 0x3f, 0x48, 0xee, 0x4f, 0xf6, 0x82, 0x00, + 0x82, 0x9e, 0xe5, 0x48, 0x95, 0x40, 0x91, 0x70, 0x62, 0xf6, 0x73, 0x1b, 0xe4, + 0x26, 0xdb, 0x94, 0x36, 0x90, 0xa9, 0x17, 0xa9, 0x6d, 0x7b, 0x87, 0x8c, 0xc9, + 0x94, 0xf7, 0xbb, 0x00, 0xa8, 0x93, 0x8b, 0x0e, 0x2f, 0x56, 0x93, 0x71, + ] + ), + test_case!( + [ + 0xba, 0x3a, 0x98, 0xa7, 0x04, 0xf5, 0xa6, 0x96, 0xc0, 0x97, 0x86, 0xa6, 0x5f, + 0xfe, 0xdb, 0x2b, 0x80, 0x3f, 0xad, 0x60, 0x99, 0x0e, 0x39, 0x21, 0x4f, 0xfd, + 0x04, 0x72, 0x40, 0x4d, 0xca, 0x57, 0xd0, 0x89, 0x9e, 0x12, 0x74, 0xae, 0x67, + 0xb5, 0x98, 0x0e, 0xe0, 0xcf, 0x37, 0x88, 0xb7, 0x59, 0x42, 0xe0, 0xe7, 0x12, + 0x4b, 0x91, 0xb4, 0x52, 0x08, 0x98, 0x90, 0xc8, 0x44, 0x4b, 0x48, 0x5d, 0x84, + 0x2e, 0x40, 0x07, 0xf3, 0xfc, 0xc4, 0x29, 0x57, 0x86, 0x57, 0x84, 0x35, 0x7f, + 0xda, 0x7d, 0xaf, + ], + [ + 0xc0, 0x28, 0x81, 0x01, 0xb4, 0x74, 0x33, 0x1c, 0x6f, 0xbf, 0xcf, 0xa9, 0x75, + 0xe3, 0x3b, 0x7a, 0x2e, 0x75, 0x98, 0x8b, + ], + [ + 0x4f, 0x37, 0x3a, 0x1a, 0x7c, 0xaa, 0x1a, 0x06, 0xf4, 0xed, 0x46, 0x45, 0x82, + 0x05, 0x09, 0x9b, 0xf1, 0x6b, 0xb2, 0xb2, 0x7f, 0x86, 0xe2, 0x43, 0xab, 0xc3, + 0x33, 0x10, 0x33, 0x34, 0x16, 0x1d, + ], + [ + 0x60, 0xa7, 0x1d, 0x42, 0x8c, 0x1a, 0xd4, 0x0b, 0x3f, 0xec, 0x68, 0xb7, 0x0f, + 0xf9, 0x06, 0xf7, 0x82, 0x02, 0xa1, 0xcc, 0x5d, 0xda, 0x0d, 0x9f, 0x46, 0xa9, + 0x43, 0x74, 0xd2, 0x4e, 0xe0, 0x38, 0xb4, 0xb0, 0x0a, 0x87, 0xd0, 0x6b, 0x28, + 0x53, 0x4f, 0x21, 0xce, 0x3f, 0xcb, 0x26, 0x7b, 0xbf, + ], + [ + 0x22, 0x9d, 0x9b, 0xa0, 0x91, 0xda, 0x8e, 0x02, 0xcc, 0xf6, 0xc0, 0x69, 0xd2, + 0x49, 0xba, 0x40, 0xf7, 0xd8, 0x1e, 0xe7, 0xee, 0xed, 0xdc, 0x35, 0x84, 0x5c, + 0x1e, 0xec, 0x00, 0x22, 0x78, 0x64, 0xbc, 0xc3, 0xfd, 0x52, 0x7a, 0xf8, 0x81, + 0x63, 0x30, 0x1f, 0xa9, 0x45, 0xbe, 0x29, 0x06, 0xee, 0xce, 0xab, 0x8b, 0x43, + 0x68, 0x51, 0x6a, 0xa3, 0x94, 0xa6, 0x8d, 0x82, 0xb2, 0x27, 0x7d, 0xc1, + ] + ), + test_case!( + [ + 0xb2, 0xd5, 0x27, 0x3a, 0x74, 0xb8, 0xf7, 0xf6, 0x53, 0xc8, 0x27, 0xa2, 0x3e, + 0x1e, 0xd1, 0x29, 0xdd, 0x0a, 0x13, 0x41, 0xb4, 0xba, 0x1f, 0x7a, 0xbc, 0x74, + 0x1f, 0x07, 0x23, 0x79, 0xc3, 0x68, 0x75, 0x6c, 0x17, 0xb7, 0x20, 0x58, 0x07, + 0x86, 0x7e, 0x17, 0x79, 0xc3, 0x0c, 0xe0, 0xaf, 0xa1, 0x7b, 0xe6, 0x20, 0xa9, + 0xa8, 0x15, 0x10, 0xc9, 0x9a, 0xad, 0x61, 0x09, 0xf0, 0xeb, 0xe8, 0x38, 0x33, + 0x0e, 0x62, 0x53, 0x46, 0xbb, 0x30, 0xbb, 0x9e, 0x63, 0x8e, 0x0a, 0x4c, 0x1d, + 0xb1, 0x4f, 0xf8, 0xf1, + ], + [ + 0x9e, 0x3f, 0xe2, 0x4b, 0x16, 0x89, 0x11, 0x74, 0x8b, 0x0e, 0x10, 0x28, 0x02, + 0xb2, 0x09, 0xb9, 0x7f, 0xc2, 0x1e, 0x40, + ], + [ + 0xcc, 0xaa, 0x31, 0xd9, 0x53, 0x54, 0xd4, 0x94, 0x68, 0x36, 0x23, 0xa1, 0x78, + 0x27, 0x27, 0x3e, 0x61, 0xf0, 0x02, 0xd0, 0xb8, 0xa1, 0x24, 0x78, 0x3f, 0xcd, + 0xbc, 0x0e, 0x6e, 0x84, 0xbf, 0x01, + ], + [ + 0xd6, 0x79, 0x53, 0x4b, 0xbf, 0x5e, 0x72, 0x81, 0x1c, 0xd9, 0xb9, 0x84, 0xb4, + 0x00, 0xa2, 0x50, 0xf7, 0x23, 0x8c, 0x88, 0x09, 0x61, 0x55, 0x44, 0xfb, 0xbf, + 0x93, 0x1b, 0x8a, 0xb7, 0x2f, 0x10, 0x70, 0x9d, 0x98, 0xf8, 0x59, 0x39, 0xd0, + 0xfc, 0x95, 0x88, 0x3d, 0x23, 0x5a, 0x93, 0xbd, 0x84, + ], + [ + 0x45, 0x21, 0x35, 0x2f, 0x3b, 0x27, 0xe2, 0x95, 0x45, 0x77, 0x1c, 0x08, 0x8c, + 0x77, 0xf6, 0x6d, 0xe7, 0xbc, 0x2d, 0x2b, 0xd7, 0x71, 0xe0, 0x11, 0x60, 0x29, + 0x9b, 0x1d, 0x18, 0x34, 0xaa, 0xf8, 0xb3, 0xf2, 0xe5, 0xb5, 0xfd, 0x80, 0xb8, + 0x7f, 0x7c, 0x3d, 0xc5, 0xb5, 0xb0, 0x2a, 0x18, 0xdf, 0x63, 0xec, 0x94, 0x81, + 0x91, 0x5f, 0x68, 0x64, 0xe2, 0x47, 0x55, 0x80, 0x73, 0xbd, 0xbc, 0x7c, + ] + ), + test_case!( + [ + 0x3a, 0x1a, 0xa4, 0xd3, 0xb2, 0x5b, 0x57, 0x88, 0xc6, 0x86, 0xdf, 0x7f, 0x60, + 0x4b, 0x0f, 0xa5, 0x46, 0x1e, 0x61, 0x28, 0xa8, 0x7a, 0x09, 0xc7, 0x47, 0x6d, + 0xa4, 0xb7, 0x30, 0xa9, 0xf7, 0x0e, 0xbf, 0x58, 0xc7, 0x8c, 0xfa, 0x62, 0x69, + 0xac, 0x9d, 0x2c, 0xfe, 0xd4, 0x45, 0x70, 0x55, 0x25, 0xee, 0x1e, 0x12, 0x28, + 0x72, 0x96, 0x65, 0xc7, 0x7c, 0xbb, 0xc7, 0x49, 0x00, 0x79, 0x53, 0xba, 0x2f, + 0x6e, 0xbe, 0xec, 0x8a, 0xf0, 0xe8, 0xff, 0xc1, 0x0d, 0x31, 0xfc, 0xf2, 0x04, + 0xe2, 0x54, 0x8b, 0x44, 0x8f, + ], + [ + 0xa6, 0x28, 0x1c, 0xd5, 0x57, 0x89, 0x30, 0x48, 0x01, 0xff, 0x6e, 0x84, 0x45, + 0x80, 0x19, 0x28, 0x4b, 0xec, 0xc9, 0xda, + ], + [ + 0x36, 0x27, 0xa9, 0x7f, 0x26, 0x85, 0xcf, 0x03, 0x0f, 0xd9, 0x75, 0xa7, 0x71, + 0xd7, 0xd6, 0xcb, 0xf9, 0x7d, 0x86, 0xf9, 0x6f, 0xcc, 0x97, 0xa8, 0xed, 0x43, + 0x22, 0xe7, 0x2f, 0xaf, 0x39, 0x84, + ], + [ + 0x61, 0xec, 0x2a, 0x18, 0x52, 0xbe, 0xc4, 0x7d, 0x84, 0xd7, 0xd9, 0xdc, 0xb3, + 0xe2, 0x5e, 0x94, 0xf2, 0x62, 0xe0, 0x42, 0xf2, 0xea, 0x65, 0x97, 0x85, 0x82, + 0x77, 0xbe, 0xea, 0x13, 0x52, 0x8d, 0x30, 0xa3, 0xda, 0x80, 0x8d, 0x62, 0x2c, + 0x56, 0xf7, 0x57, 0x8c, 0xf2, 0x93, 0xc3, 0x2b, 0xf2, + ], + [ + 0x63, 0xde, 0xd0, 0x79, 0x47, 0x76, 0xb7, 0x63, 0xb9, 0x48, 0xfd, 0x29, 0x5c, + 0xc0, 0x70, 0xf3, 0xb0, 0x89, 0x13, 0x45, 0xea, 0xb9, 0xec, 0x80, 0xd3, 0xdd, + 0x79, 0xad, 0x22, 0x22, 0xa4, 0x56, 0xb0, 0xf2, 0xaa, 0x80, 0x22, 0xe2, 0x23, + 0xc3, 0xcb, 0x25, 0x84, 0x8d, 0xbe, 0x92, 0xd9, 0x8d, 0x45, 0xb4, 0xa2, 0xc1, + 0xa0, 0x7e, 0x98, 0xfa, 0x81, 0x94, 0x46, 0x97, 0xf9, 0x4a, 0xd7, 0xf6, + ] + ), + test_case!( + [ + 0x5e, 0x80, 0xab, 0x35, 0x62, 0x28, 0xe1, 0x81, 0x50, 0xe8, 0xd2, 0x3f, 0x1e, + 0x58, 0x74, 0xb8, 0x41, 0x55, 0x17, 0x4d, 0x13, 0xba, 0xff, 0x53, 0x07, 0xf3, + 0x52, 0x42, 0x19, 0x8d, 0x34, 0x56, 0x08, 0x5a, 0x34, 0xc6, 0x7f, 0x5c, 0x60, + 0xd3, 0xed, 0x95, 0x68, 0xcc, 0x69, 0xa4, 0xca, 0x4b, 0x7a, 0xe6, 0x28, 0x9b, + 0x87, 0xb1, 0xa5, 0x39, 0x49, 0x3f, 0x50, 0xb6, 0x26, 0x31, 0x5e, 0xa7, 0xf3, + 0x43, 0x6f, 0xa0, 0xee, 0xc7, 0xdf, 0x0a, 0xcc, 0xae, 0xd6, 0xa2, 0x59, 0x01, + 0x5f, 0xcf, 0x71, 0x49, 0x97, 0xc5, + ], + [ + 0x3d, 0x37, 0x10, 0x21, 0xe7, 0x3f, 0x1f, 0xd5, 0xca, 0xa0, 0x41, 0xa3, 0xb4, + 0xd4, 0xa5, 0x64, 0xc6, 0x4c, 0x04, 0x92, + ], + [ + 0x7e, 0xca, 0x32, 0x96, 0x12, 0x8b, 0x47, 0xb5, 0xf3, 0xe4, 0xc2, 0xee, 0x68, + 0xf3, 0x97, 0x4b, 0x5c, 0xbb, 0xf6, 0xd3, 0x10, 0x45, 0x6e, 0xce, 0x50, 0xf6, + 0xb9, 0x85, 0x17, 0xdd, 0x6b, 0x17, + ], + [ + 0xd0, 0x3f, 0x40, 0x7e, 0xa2, 0x69, 0x09, 0xc8, 0x33, 0x11, 0xb7, 0x07, 0x95, + 0x0d, 0xa9, 0xad, 0xf7, 0x1f, 0xdc, 0xdb, 0x07, 0x56, 0x96, 0x33, 0xb8, 0xfd, + 0x74, 0xa6, 0x5c, 0x39, 0x71, 0x46, 0xe9, 0xd8, 0xd9, 0x10, 0x68, 0x0d, 0x33, + 0x35, 0x38, 0xac, 0xca, 0x4b, 0x68, 0x00, 0xc7, 0xf5, + ], + [ + 0x89, 0x4f, 0xfa, 0xd9, 0xb5, 0x47, 0xd7, 0xae, 0x7a, 0x97, 0xfb, 0x82, 0xf6, + 0xad, 0xde, 0xbc, 0xf9, 0xf9, 0xd9, 0x24, 0x61, 0x04, 0x55, 0xf6, 0x8d, 0xf1, + 0x79, 0x31, 0xf7, 0xb8, 0x9c, 0x2e, 0xcd, 0x88, 0x98, 0x6c, 0xfa, 0xdc, 0x37, + 0xfe, 0xc8, 0xc6, 0xec, 0x4e, 0x16, 0xda, 0x5f, 0x8b, 0x7f, 0xda, 0x0a, 0x11, + 0xe9, 0x92, 0xde, 0x63, 0x51, 0xc0, 0x6e, 0xea, 0xb8, 0xcc, 0x6b, 0x34, + ] + ), + test_case!( + [ + 0xfa, 0xf5, 0x61, 0x5e, 0x3d, 0x18, 0x78, 0x43, 0xdf, 0xed, 0x6b, 0xf1, 0x08, + 0xd8, 0x69, 0xe8, 0x22, 0x1f, 0x48, 0xce, 0x8f, 0x76, 0x54, 0xff, 0xc3, 0xbf, + 0x42, 0x31, 0xeb, 0x65, 0x8b, 0x4d, 0x15, 0x4a, 0x6e, 0x38, 0xf6, 0xaa, 0xac, + 0xbb, 0xe2, 0xbd, 0x06, 0xf6, 0xb3, 0x22, 0x2c, 0xca, 0x58, 0x01, 0x34, 0xd3, + 0x0c, 0xa6, 0xd0, 0xed, 0x2b, 0x28, 0x57, 0xf8, 0xb5, 0xeb, 0x9d, 0xf1, 0xa8, + 0xf4, 0x3e, 0x0d, 0x67, 0x05, 0xbb, 0xe2, 0x4a, 0x69, 0x7b, 0xa7, 0x9f, 0x0f, + 0x31, 0xa8, 0x49, 0x4b, 0x9d, 0x54, 0xd6, + ], + [ + 0xfe, 0xa8, 0xd3, 0x53, 0x2f, 0x48, 0x06, 0xaa, 0xd4, 0x94, 0xce, 0xa0, 0xcc, + 0xc9, 0x5b, 0x5e, 0x99, 0xa5, 0x1f, 0xd9, + ], + [ + 0x57, 0x26, 0x38, 0x9b, 0x03, 0x68, 0xa9, 0x28, 0xcc, 0x16, 0x65, 0xd7, 0x56, + 0x18, 0xb9, 0x33, 0x74, 0x86, 0x97, 0xfc, 0x7a, 0x0a, 0x36, 0x4b, 0xda, 0xd0, + 0x24, 0x66, 0xe9, 0x5c, 0x0a, 0x3d, + ], + [ + 0x25, 0x31, 0x26, 0x5d, 0xbb, 0x78, 0x2a, 0xa7, 0x1a, 0x1e, 0x8b, 0x24, 0xdd, + 0xbd, 0xf0, 0xe8, 0xcb, 0x0c, 0x84, 0x35, 0x66, 0x03, 0x10, 0x42, 0x94, 0x49, + 0xf7, 0x16, 0x37, 0x66, 0x9e, 0xdc, 0x35, 0xb9, 0x69, 0xec, 0x0b, 0x42, 0x66, + 0x79, 0x6e, 0xd7, 0xfa, 0x4f, 0x37, 0xc3, 0x33, 0x25, + ], + [ + 0xd5, 0x6b, 0xe6, 0x65, 0x61, 0xc2, 0x08, 0xe0, 0x85, 0xdc, 0x81, 0xe1, 0x41, + 0x54, 0xbb, 0x0a, 0xcc, 0xfb, 0xf8, 0x3e, 0x2e, 0xdf, 0x31, 0xc4, 0x68, 0x3d, + 0x03, 0x87, 0x04, 0x03, 0x5e, 0xc8, 0x3a, 0xc2, 0x5a, 0xe0, 0x2c, 0x62, 0x90, + 0x33, 0xc7, 0xd1, 0x64, 0xe1, 0xe9, 0xff, 0x20, 0x43, 0x46, 0x60, 0x1a, 0x8d, + 0x70, 0x00, 0x60, 0xdd, 0x1e, 0x84, 0x16, 0x5b, 0x53, 0x93, 0x03, 0xc7, + ] + ), + test_case!( + [ + 0x1b, 0x27, 0xa7, 0x1d, 0x7f, 0x5a, 0x9e, 0xb7, 0x49, 0xe9, 0x37, 0x2d, 0x6c, + 0xc7, 0x21, 0xb9, 0xd7, 0x26, 0x9a, 0xa2, 0x3a, 0x23, 0x6c, 0x70, 0xc6, 0x09, + 0xd0, 0x93, 0xfd, 0xbd, 0x30, 0x74, 0x41, 0xcb, 0x6f, 0x56, 0x70, 0xc7, 0x43, + 0xcb, 0x2d, 0x6b, 0xd5, 0xfe, 0x6e, 0xd5, 0xa2, 0x0c, 0x65, 0xaf, 0xab, 0x3d, + 0x81, 0x57, 0x94, 0xc2, 0x21, 0xf2, 0x59, 0x12, 0xac, 0x1d, 0xc2, 0x8f, 0x1f, + 0xf7, 0xb4, 0x6a, 0x98, 0xb0, 0x15, 0x76, 0x07, 0xc7, 0x3e, 0xd3, 0x61, 0x74, + 0x20, 0x21, 0x07, 0xc3, 0x65, 0x66, 0x2c, 0x69, + ], + [ + 0xfe, 0x5d, 0x0a, 0x51, 0xb5, 0x15, 0x97, 0x07, 0x30, 0xe7, 0x9b, 0x0c, 0xff, + 0xb7, 0x5c, 0x4b, 0xee, 0x10, 0x0a, 0x0d, + ], + [ + 0x71, 0x86, 0xe6, 0xcb, 0xaa, 0xe2, 0x86, 0x47, 0x84, 0x50, 0x44, 0x39, 0xd1, + 0x37, 0xf5, 0xf8, 0xbf, 0x29, 0x9a, 0xd6, 0x02, 0x80, 0x7c, 0xa6, 0xdc, 0x98, + 0xc6, 0x91, 0x19, 0xaf, 0x88, 0x9d, + ], + [ + 0x45, 0xb1, 0x82, 0x34, 0x71, 0xae, 0xa0, 0x29, 0xaa, 0x27, 0xf1, 0xc0, 0x4d, + 0x63, 0xab, 0xde, 0xda, 0x26, 0x97, 0x9e, 0x16, 0xa9, 0x22, 0xad, 0x23, 0x74, + 0x5b, 0xfc, 0xc4, 0xa8, 0xab, 0x47, 0xa5, 0x38, 0x43, 0x46, 0x57, 0x88, 0x11, + 0x1e, 0x3c, 0xd5, 0x96, 0xe5, 0x7e, 0x03, 0x4a, 0x34, + ], + [ + 0x0c, 0x30, 0xb8, 0xa9, 0x6a, 0xec, 0x86, 0x0b, 0xaa, 0x72, 0x0e, 0xc0, 0xd0, + 0xcb, 0x96, 0xdc, 0xbb, 0xab, 0x0e, 0x0d, 0xb4, 0xb1, 0x5b, 0x60, 0xc8, 0x06, + 0xd7, 0x62, 0x2d, 0xa7, 0x30, 0x3a, 0x82, 0x84, 0x1f, 0x4f, 0x5b, 0x9a, 0xcd, + 0x12, 0x26, 0x29, 0x8a, 0x13, 0x96, 0x9e, 0xad, 0x77, 0x48, 0xe5, 0x59, 0x37, + 0x7d, 0x90, 0x17, 0x10, 0xc1, 0x40, 0x48, 0xab, 0x92, 0x2c, 0x30, 0x53, + ] + ), + test_case!( + [ + 0xa8, 0x72, 0x57, 0xc0, 0xff, 0x86, 0xb7, 0x84, 0x6a, 0xc3, 0xff, 0x7f, 0x90, + 0x02, 0xba, 0x53, 0xc0, 0xb7, 0x50, 0x48, 0x4d, 0x20, 0xa6, 0xab, 0x6d, 0x6c, + 0x1a, 0xbf, 0xac, 0x5f, 0x20, 0x16, 0x90, 0x61, 0x7b, 0xfb, 0x2e, 0x44, 0xbb, + 0x60, 0xe9, 0x00, 0x5f, 0xd1, 0xb5, 0xfc, 0xe0, 0x75, 0x69, 0x61, 0x9b, 0xca, + 0x7e, 0xfc, 0x54, 0x43, 0x81, 0x66, 0xfa, 0xbf, 0xeb, 0xbd, 0xac, 0x04, 0x16, + 0xe1, 0x2e, 0x89, 0x7b, 0x4f, 0x3f, 0xef, 0x36, 0xac, 0x30, 0x0c, 0x50, 0xff, + 0x2a, 0x99, 0xfc, 0x5c, 0xa7, 0x39, 0x16, 0x16, 0xc7, + ], + [ + 0x52, 0xe3, 0x90, 0x87, 0x5c, 0xc0, 0x19, 0xd0, 0xaa, 0x47, 0x3e, 0x86, 0x63, + 0xf8, 0xfe, 0xfb, 0xbb, 0x31, 0x90, 0xd2, + ], + [ + 0x7f, 0xec, 0x36, 0xac, 0xc9, 0x0c, 0xfa, 0x26, 0xd3, 0x4c, 0x3d, 0x3d, 0x55, + 0x67, 0xd2, 0x88, 0x54, 0x81, 0x07, 0xb8, 0x36, 0xd7, 0x35, 0x87, 0xe2, 0xca, + 0x7c, 0x0d, 0xaa, 0xe4, 0x5a, 0x5a, + ], + [ + 0x37, 0x0c, 0x87, 0xe5, 0x59, 0x7c, 0x71, 0x5d, 0x47, 0x22, 0x03, 0x76, 0xd2, + 0x86, 0xca, 0xf6, 0x8f, 0xd8, 0x19, 0x5a, 0xd9, 0x0e, 0x9a, 0xbb, 0x5b, 0xac, + 0x9a, 0xc3, 0xa4, 0xf6, 0xea, 0xe2, 0xe2, 0x91, 0x23, 0x40, 0x6f, 0xbf, 0xcd, + 0x5d, 0x2d, 0x02, 0x32, 0xfa, 0x85, 0xd8, 0x83, 0x89, + ], + [ + 0x80, 0xeb, 0x72, 0xd7, 0x19, 0xda, 0xd7, 0x9b, 0x94, 0xeb, 0x27, 0x1d, 0x27, + 0xea, 0x34, 0x3d, 0xd4, 0x06, 0x44, 0x2e, 0x1c, 0x79, 0x2b, 0x4b, 0x99, 0x40, + 0x73, 0x5c, 0xbe, 0x95, 0x92, 0x35, 0xb4, 0xa4, 0xea, 0xbf, 0xf4, 0xc6, 0x91, + 0x2e, 0xf1, 0xc0, 0x90, 0x7a, 0xb4, 0x5a, 0x35, 0xaf, 0x59, 0xeb, 0xf0, 0x6b, + 0x09, 0xff, 0xb8, 0x81, 0xa6, 0x7f, 0x83, 0xd1, 0x93, 0xfa, 0x16, 0x31, + ] + ), + test_case!( + [ + 0xde, 0xfe, 0xed, 0x0b, 0xf4, 0xcc, 0x79, 0x9e, 0xc4, 0x06, 0xdb, 0x1e, 0xcc, + 0x19, 0xde, 0xaa, 0x6f, 0xa0, 0x51, 0x2b, 0x04, 0xd9, 0x69, 0x71, 0x79, 0xa1, + 0x3e, 0xc7, 0x0e, 0x9b, 0xe6, 0xbb, 0xa1, 0x40, 0x39, 0x52, 0x88, 0x73, 0x55, + 0x99, 0xce, 0x29, 0xc2, 0xb9, 0x19, 0xb9, 0xf3, 0x0f, 0x9a, 0x4f, 0x84, 0xcd, + 0xd6, 0x3b, 0x77, 0x07, 0xaf, 0xaa, 0x7e, 0xa3, 0xf3, 0x73, 0x9c, 0xd3, 0x57, + 0x8b, 0x00, 0xbb, 0x9e, 0x56, 0x8c, 0x43, 0x7d, 0x3f, 0xee, 0x5d, 0x44, 0x5d, + 0x46, 0x90, 0x2c, 0x59, 0xff, 0x00, 0xe0, 0x8f, 0x05, 0x64, + ], + [ + 0xe5, 0xeb, 0xe8, 0x67, 0xef, 0x21, 0xc3, 0xfd, 0x82, 0x15, 0xa7, 0x66, 0x08, + 0x89, 0xce, 0x04, 0x17, 0xad, 0xdf, 0x01, + ], + [ + 0x7b, 0x2c, 0xf0, 0x87, 0xc6, 0x68, 0x65, 0x8f, 0x4b, 0x94, 0x64, 0xb5, 0x56, + 0x92, 0xbc, 0xe1, 0x8a, 0x63, 0x3b, 0x5b, 0xf5, 0x30, 0xd0, 0xb4, 0xb6, 0x14, + 0xef, 0x40, 0xbf, 0x3c, 0xdf, 0x1c, + ], + [ + 0x5c, 0x43, 0xcd, 0x0e, 0x87, 0x2c, 0x9b, 0x51, 0x5f, 0x4b, 0x4a, 0x66, 0x39, + 0x32, 0x46, 0x71, 0xc3, 0xa3, 0x2a, 0xe0, 0xbb, 0x20, 0x4e, 0x4f, 0xe1, 0xbc, + 0x74, 0x08, 0xed, 0x64, 0xb4, 0xc4, 0xb3, 0x34, 0x40, 0x4e, 0x84, 0x6c, 0x3a, + 0x81, 0x36, 0xea, 0xcf, 0x0e, 0x7a, 0xbf, 0x90, 0x43, + ], + [ + 0x61, 0x0d, 0x53, 0xba, 0x5a, 0x43, 0xe0, 0x47, 0xf8, 0x60, 0xed, 0x99, 0x61, + 0x74, 0x1d, 0x18, 0x6e, 0x06, 0x83, 0xfa, 0x2a, 0x7a, 0xc3, 0x12, 0x45, 0x28, + 0x38, 0x46, 0x9f, 0x2c, 0xd6, 0x9e, 0xbf, 0xc7, 0xe2, 0x77, 0xe0, 0x4a, 0x7f, + 0x4e, 0x59, 0x08, 0x94, 0xf3, 0x32, 0x3a, 0xaf, 0xe5, 0x41, 0x49, 0x23, 0x2b, + 0xc4, 0x8f, 0x0d, 0x8c, 0xd3, 0x74, 0xcc, 0x79, 0x2f, 0xd1, 0x68, 0xb7, + ] + ), + test_case!( + [ + 0x93, 0x6a, 0xfa, 0xf9, 0x63, 0xb3, 0x57, 0x0d, 0x66, 0x5e, 0xb3, 0xe2, 0xf4, + 0x43, 0xbd, 0x8f, 0xbe, 0x7e, 0xa7, 0x65, 0x20, 0x03, 0xbe, 0x67, 0x0d, 0x10, + 0xdc, 0x48, 0x1c, 0xf6, 0x31, 0x56, 0x8a, 0x4b, 0x96, 0x92, 0xc6, 0x15, 0xea, + 0xdc, 0xe8, 0xd6, 0x3f, 0x6c, 0xad, 0x05, 0x0a, 0xca, 0xd2, 0xc7, 0x34, 0xb9, + 0x06, 0xf4, 0x24, 0xcf, 0x2f, 0x8d, 0xbd, 0x6e, 0xe7, 0x6f, 0x40, 0xf8, 0x35, + 0xab, 0x75, 0x6e, 0x41, 0xe2, 0x9e, 0x33, 0x77, 0x27, 0x07, 0xf4, 0xbc, 0x75, + 0x9f, 0x23, 0xfc, 0xee, 0x4a, 0x40, 0x5a, 0x93, 0xbf, 0x6f, 0xb9, + ], + [ + 0x81, 0x0f, 0x96, 0xcb, 0x7f, 0x0f, 0x0c, 0xd1, 0xb1, 0x81, 0xf6, 0x1f, 0x03, + 0x82, 0x62, 0x46, 0x47, 0x78, 0xad, 0x6e, + ], + [ + 0x44, 0x84, 0x77, 0xea, 0xa7, 0x51, 0xf3, 0x6e, 0x74, 0x96, 0x2b, 0xa3, 0xca, + 0x11, 0xb7, 0xa6, 0xf7, 0x4d, 0xd8, 0xd4, 0x54, 0x4c, 0xfa, 0x71, 0x5f, 0x68, + 0x00, 0xda, 0x46, 0xa7, 0xa9, 0xf0, + ], + [ + 0xa7, 0xe1, 0x29, 0x03, 0x28, 0x29, 0x22, 0x00, 0x21, 0x98, 0x60, 0x1b, 0xe0, + 0x26, 0xda, 0xbc, 0x19, 0x58, 0x5c, 0x0b, 0x1d, 0x6a, 0x82, 0xd7, 0x18, 0x44, + 0xa2, 0x91, 0xe4, 0x7c, 0xce, 0x6e, 0xae, 0x4c, 0x54, 0x1c, 0xdf, 0xa5, 0x0a, + 0x0c, 0x5f, 0xb2, 0x76, 0x02, 0x32, 0x5f, 0x8e, 0x05, + ], + [ + 0xbf, 0x4a, 0x53, 0xea, 0x81, 0xb4, 0x3b, 0x94, 0x0b, 0xde, 0xab, 0x7c, 0x34, + 0x84, 0x1b, 0x8c, 0x6f, 0x7d, 0xf8, 0x34, 0x13, 0x57, 0x77, 0x51, 0x12, 0x48, + 0xc9, 0xc2, 0xc1, 0xb8, 0xa3, 0x8c, 0xf6, 0x2b, 0x14, 0xcc, 0x47, 0xe5, 0xa1, + 0xd2, 0xf9, 0xf7, 0xd9, 0x78, 0xc9, 0x38, 0x9a, 0xcc, 0xdb, 0x67, 0x25, 0xe2, + 0x39, 0xab, 0x8f, 0x15, 0xc4, 0xdc, 0x51, 0xbe, 0x1f, 0xa2, 0x4c, 0x9d, + ] + ), + test_case!( + [ + 0xa5, 0x28, 0x18, 0xd8, 0x0b, 0xab, 0x0f, 0x50, 0x1e, 0x64, 0x5b, 0x32, 0x27, + 0x2c, 0x86, 0xc3, 0xdd, 0x73, 0x9a, 0x50, 0x9b, 0x88, 0x90, 0x37, 0xff, 0x70, + 0xa0, 0x8a, 0x8e, 0x96, 0x9e, 0xd6, 0x02, 0xf4, 0xfd, 0x37, 0xf9, 0x76, 0x92, + 0x88, 0x71, 0x30, 0x64, 0x41, 0x73, 0xe7, 0x53, 0x3e, 0x15, 0x84, 0xa9, 0xc5, + 0x23, 0xdb, 0x68, 0xf8, 0x14, 0xa4, 0xae, 0x02, 0xff, 0x98, 0xd3, 0x9e, 0xde, + 0xdc, 0x8c, 0xa3, 0x95, 0x62, 0xa8, 0xed, 0x1e, 0xad, 0x0f, 0x96, 0xcf, 0x7c, + 0x73, 0x29, 0x50, 0x02, 0x53, 0xb4, 0x8d, 0x06, 0xbc, 0x38, 0x20, 0x05, + ], + [ + 0x3e, 0xec, 0x10, 0x1f, 0x47, 0x63, 0xc4, 0x3f, 0xbd, 0xaf, 0x3d, 0x41, 0xea, + 0x97, 0x57, 0x81, 0x6a, 0x7b, 0x20, 0xb5, + ], + [ + 0x89, 0x6d, 0x0e, 0x73, 0x64, 0xd3, 0xeb, 0xbc, 0xa0, 0x0d, 0x11, 0x57, 0xd3, + 0x3f, 0x5e, 0x3e, 0x83, 0xa1, 0xd7, 0x87, 0x63, 0x39, 0x3e, 0x08, 0x37, 0x8a, + 0xb6, 0x8a, 0x6e, 0x6a, 0x77, 0xce, + ], + [ + 0x0b, 0x84, 0x2b, 0xca, 0xa0, 0x9f, 0xff, 0xef, 0x99, 0x96, 0x68, 0x40, 0x78, + 0x1e, 0xcd, 0xc1, 0xf3, 0x27, 0x11, 0xfa, 0x66, 0x81, 0x46, 0x43, 0x42, 0x3f, + 0x06, 0x11, 0xa7, 0xf6, 0xf4, 0x5c, 0x9d, 0xbf, 0xc6, 0x5e, 0x0e, 0x3e, 0x1b, + 0x36, 0x4b, 0x03, 0xb4, 0x70, 0x7d, 0x2d, 0x0f, 0xf6, + ], + [ + 0x95, 0x9b, 0x3d, 0x64, 0xc5, 0x32, 0x58, 0xb3, 0xda, 0x57, 0xa4, 0x8f, 0x5c, + 0xda, 0xae, 0x64, 0x6e, 0x98, 0xb0, 0x0b, 0x69, 0x14, 0x34, 0xed, 0xab, 0x4e, + 0xd6, 0x15, 0x4e, 0x99, 0x94, 0x0e, 0xcc, 0x75, 0x1c, 0xaf, 0xb0, 0x92, 0x36, + 0x82, 0x3b, 0x7c, 0xd2, 0xee, 0xca, 0xe3, 0x8a, 0x7d, 0xc9, 0x31, 0x67, 0x5b, + 0xd2, 0x92, 0xbc, 0xdd, 0xf3, 0x1b, 0x57, 0xef, 0xcd, 0xf4, 0xc7, 0xf7, + ] + ), + test_case!( + [ + 0xbe, 0xc0, 0xc0, 0xce, 0x37, 0xb7, 0xe0, 0x04, 0x1e, 0x2e, 0xca, 0x66, 0x45, + 0xc6, 0x77, 0x04, 0x73, 0x4a, 0xf8, 0x58, 0x73, 0xa5, 0x56, 0x2b, 0x9a, 0x3a, + 0xcb, 0x39, 0xed, 0x1c, 0x66, 0xbf, 0x33, 0x5d, 0x72, 0x12, 0xb5, 0x93, 0x40, + 0xb9, 0xca, 0x1c, 0x08, 0x4f, 0x6e, 0x92, 0xbd, 0xdd, 0xc8, 0xcd, 0xaf, 0x50, + 0xe9, 0x9f, 0x73, 0x09, 0x36, 0x38, 0x71, 0xb7, 0x77, 0xa4, 0x92, 0x66, 0x86, + 0x08, 0x1a, 0xcc, 0xf5, 0x8d, 0xf1, 0x8c, 0xbe, 0x6b, 0x01, 0x12, 0xd8, 0x2b, + 0xf0, 0x1e, 0x75, 0xe2, 0xe3, 0x15, 0xb3, 0x1a, 0xfb, 0xd2, 0xe4, 0x5f, 0x2c, + ], + [ + 0x9f, 0x36, 0xfa, 0x6a, 0x1e, 0x0e, 0xfa, 0x50, 0x64, 0xff, 0x56, 0x66, 0xe8, + 0xce, 0xd5, 0x59, 0x2d, 0x9d, 0xc3, 0x90, + ], + [ + 0xf1, 0xd7, 0x2b, 0x13, 0x99, 0xe1, 0x05, 0xdc, 0x4f, 0xc3, 0xab, 0xf6, 0xa7, + 0x1f, 0x62, 0x38, 0x0e, 0xac, 0x31, 0xe3, 0x3b, 0x10, 0x65, 0x14, 0xbc, 0x28, + 0xdb, 0x03, 0x2c, 0xc6, 0x9e, 0xd5, + ], + [ + 0xb1, 0x03, 0xf9, 0x6a, 0x68, 0x5b, 0xdb, 0x31, 0xbd, 0xf8, 0x75, 0xc5, 0x60, + 0x98, 0x05, 0x0a, 0xd3, 0x67, 0xc2, 0xc1, 0xd2, 0xcf, 0x89, 0x94, 0x6e, 0x27, + 0x78, 0xc1, 0x86, 0xf7, 0xfe, 0xb1, 0xd5, 0x5b, 0xb2, 0x19, 0x85, 0x91, 0x98, + 0x32, 0x05, 0xf1, 0x1a, 0x3b, 0x73, 0xef, 0x41, 0x07, + ], + [ + 0x5d, 0x83, 0xc3, 0xc9, 0xa2, 0x00, 0xa5, 0xc9, 0x1d, 0x50, 0x4d, 0x18, 0x61, + 0xcd, 0x7e, 0xe5, 0xff, 0x18, 0x23, 0x30, 0xf1, 0x21, 0x07, 0xe9, 0x1b, 0x39, + 0x92, 0xe2, 0x89, 0x09, 0x82, 0x58, 0x94, 0x77, 0x42, 0xc7, 0xcb, 0x0d, 0xbd, + 0xa9, 0x74, 0xc6, 0xda, 0x37, 0xc3, 0x1f, 0x94, 0x55, 0x6e, 0xb4, 0x55, 0xe9, + 0x08, 0x75, 0x72, 0xe9, 0x23, 0x93, 0x17, 0xcd, 0x0b, 0x0e, 0xdd, 0x31, + ] + ), + test_case!( + [ + 0x43, 0xe9, 0x04, 0x00, 0x8a, 0x82, 0x9b, 0x5d, 0x3b, 0xe6, 0x0d, 0x86, 0x6e, + 0x0a, 0x66, 0x28, 0xee, 0xed, 0xc2, 0xf3, 0x1c, 0x7b, 0xc2, 0x52, 0x6f, 0x63, + 0xb8, 0x0c, 0xa4, 0xed, 0xbb, 0xa2, 0x6b, 0x54, 0xf1, 0xdb, 0xb9, 0x1f, 0x8e, + 0x69, 0x8f, 0xb0, 0x35, 0x68, 0xed, 0xdd, 0x71, 0x6f, 0x90, 0x1a, 0x47, 0x9f, + 0x59, 0xb2, 0xda, 0xf2, 0x68, 0x3d, 0xa2, 0xa6, 0xe3, 0x34, 0x2b, 0x10, 0x0c, + 0x76, 0xe0, 0x86, 0x4f, 0x14, 0xa1, 0xcd, 0xc5, 0xa5, 0x7e, 0x36, 0xb4, 0xa5, + 0x12, 0x01, 0xb1, 0x9e, 0xbb, 0x78, 0x0c, 0x9a, 0x4e, 0x02, 0xc4, 0x54, 0x22, + 0x99, + ], + [ + 0x21, 0xd0, 0xf2, 0xcd, 0x12, 0xcc, 0x7d, 0x73, 0xd4, 0x29, 0x7a, 0x29, 0xbc, + 0xdf, 0xfd, 0x39, 0xc6, 0x39, 0x4b, 0x36, + ], + [ + 0x1d, 0x28, 0xb5, 0x20, 0xfa, 0xb1, 0xc0, 0xae, 0x6f, 0xcf, 0x8f, 0xd0, 0xe1, + 0xa9, 0xdc, 0x5b, 0x59, 0xae, 0x47, 0xf3, 0xff, 0xa2, 0x2b, 0xdf, 0xb0, 0x68, + 0x91, 0xde, 0xf3, 0x05, 0x1b, 0xf4, + ], + [ + 0x43, 0x11, 0xfb, 0xf9, 0xf2, 0x79, 0x96, 0x74, 0xc5, 0x5c, 0xd9, 0xc1, 0xa1, + 0xbb, 0x51, 0x21, 0x5f, 0x89, 0xac, 0xc8, 0xaf, 0x83, 0x85, 0x53, 0x13, 0xa7, + 0x67, 0x3f, 0x09, 0x67, 0x33, 0x15, 0xab, 0xf1, 0xfd, 0x67, 0x5d, 0x0b, 0x6b, + 0x20, 0x8d, 0x59, 0x2c, 0x61, 0xa4, 0x29, 0x8a, 0x33, + ], + [ + 0x62, 0xc7, 0x01, 0xa7, 0xdb, 0x46, 0xdf, 0x1c, 0x04, 0xd0, 0x11, 0x71, 0xab, + 0x08, 0x13, 0x01, 0x61, 0x24, 0x44, 0x8b, 0xda, 0xc2, 0xc1, 0x90, 0x9f, 0x1c, + 0xdf, 0x76, 0xa3, 0x4f, 0x27, 0x83, 0x26, 0x3b, 0x9d, 0xda, 0x20, 0x56, 0x83, + 0x31, 0x47, 0x6d, 0x33, 0xf2, 0x44, 0xe0, 0x1c, 0x5c, 0xce, 0x55, 0x99, 0xd3, + 0x6b, 0xd0, 0x1b, 0x31, 0xb0, 0x14, 0x1d, 0xf2, 0xfa, 0xa8, 0x01, 0xfa, + ] + ), + test_case!( + [ + 0x73, 0x32, 0xc6, 0x58, 0x9e, 0xa1, 0x1f, 0x59, 0xe4, 0x61, 0xd1, 0x7a, 0xa7, + 0xbd, 0xf4, 0x15, 0xd1, 0x1c, 0xae, 0x71, 0xd2, 0x0c, 0x14, 0x15, 0xb3, 0x7d, + 0xe6, 0x03, 0x12, 0xb4, 0x2f, 0xec, 0x6a, 0xcf, 0x9c, 0x79, 0x18, 0xe8, 0xf3, + 0x85, 0x4c, 0x47, 0xfd, 0x02, 0xba, 0x77, 0x86, 0x81, 0x55, 0x03, 0x40, 0x6d, + 0x8e, 0x2c, 0x3c, 0x1c, 0x7f, 0x96, 0x9e, 0x5b, 0x6b, 0x39, 0x53, 0xcc, 0x5b, + 0xd9, 0x38, 0x47, 0xc8, 0xf3, 0xae, 0xef, 0x21, 0x22, 0x82, 0x1c, 0x12, 0x3d, + 0x49, 0xd1, 0x80, 0x1c, 0x8a, 0x26, 0x65, 0x8b, 0xd0, 0x1a, 0xcf, 0x0d, 0xf2, + 0x78, 0x55, + ], + [ + 0x10, 0x17, 0x15, 0x4a, 0xf9, 0xee, 0xae, 0xc1, 0xc6, 0x0d, 0x3b, 0x10, 0xd1, + 0x47, 0xf7, 0xf1, 0x4b, 0xf4, 0x25, 0x3f, + ], + [ + 0x4b, 0x59, 0x21, 0x3d, 0x09, 0xe8, 0x45, 0x2c, 0x9d, 0x66, 0xaf, 0x56, 0xc2, + 0x4a, 0x38, 0x02, 0xf1, 0xf9, 0x37, 0xc7, 0x45, 0xe9, 0x60, 0xe0, 0x1e, 0x2e, + 0xfc, 0x50, 0x0f, 0x83, 0x8b, 0x22, + ], + [ + 0x0a, 0xc3, 0xe0, 0xb3, 0xb2, 0x3a, 0xf8, 0x05, 0xa3, 0xdf, 0x8c, 0x1d, 0x9c, + 0xa3, 0xd8, 0xd2, 0xe5, 0xb2, 0x18, 0x52, 0xe0, 0xd8, 0x77, 0x36, 0xa6, 0x0e, + 0x90, 0x38, 0x08, 0x27, 0xcf, 0xb9, 0xf3, 0x15, 0xd6, 0xf9, 0x73, 0x5a, 0xa8, + 0x52, 0xd8, 0x4a, 0xf5, 0xd6, 0x1c, 0x36, 0x56, 0x3f, + ], + [ + 0xc1, 0x38, 0x0f, 0x19, 0xdc, 0xae, 0x59, 0x02, 0x85, 0xca, 0xe2, 0x3d, 0xf3, + 0xf1, 0x52, 0xa3, 0x7d, 0xfd, 0xe1, 0x19, 0x19, 0x01, 0x8f, 0x93, 0x30, 0x49, + 0xf3, 0x20, 0x27, 0xb3, 0x34, 0x27, 0x66, 0x8e, 0xfa, 0x19, 0xd9, 0xa1, 0xf4, + 0x8e, 0x83, 0x1d, 0x81, 0x93, 0x57, 0x32, 0x82, 0x2d, 0x4d, 0xfb, 0xf4, 0xbe, + 0x64, 0x2e, 0x70, 0x0f, 0xfd, 0x49, 0x5b, 0xce, 0xa9, 0xc2, 0x87, 0xbb, + ] + ), + test_case!( + [ + 0x8d, 0x29, 0x27, 0x28, 0x29, 0x61, 0xb0, 0xc9, 0xab, 0x3e, 0x06, 0x13, 0x1b, + 0x26, 0xac, 0x3e, 0xde, 0x6f, 0x45, 0x55, 0xf2, 0x22, 0x9d, 0xf8, 0x65, 0x1c, + 0x2e, 0xfc, 0x7e, 0x68, 0x46, 0xf4, 0x7b, 0x07, 0xb1, 0xc6, 0xc2, 0x29, 0xdc, + 0x04, 0xdd, 0x5d, 0xff, 0x47, 0x95, 0x10, 0x59, 0xab, 0x16, 0x86, 0x3b, 0x45, + 0x5b, 0x7b, 0x54, 0x7f, 0xc0, 0x0d, 0x8a, 0xe9, 0x0a, 0xb8, 0xc9, 0x93, 0xda, + 0xb8, 0x51, 0xb8, 0xbe, 0xb9, 0xf4, 0x8b, 0xee, 0x74, 0x26, 0xac, 0x4c, 0xbb, + 0xb3, 0xfd, 0x71, 0xf6, 0x9f, 0xff, 0xac, 0x13, 0x7e, 0x4d, 0xa1, 0xa7, 0x64, + 0x66, 0xd9, 0x2c, + ], + [ + 0xf6, 0x43, 0x95, 0xf1, 0x92, 0xc2, 0xd5, 0xae, 0xe3, 0x2c, 0x54, 0xb3, 0x12, + 0xe9, 0x54, 0x28, 0xf6, 0x81, 0x5a, 0xc4, + ], + [ + 0x47, 0xf6, 0x91, 0xf4, 0xd2, 0x11, 0x2f, 0xb6, 0xc4, 0xba, 0xf8, 0xce, 0xf2, + 0xff, 0x98, 0x67, 0xfa, 0xb7, 0x41, 0xbe, 0xe5, 0x55, 0xec, 0xae, 0x34, 0x70, + 0xd6, 0x11, 0xba, 0x21, 0xe7, 0x24, + ], + [ + 0xa6, 0xaa, 0xd9, 0x37, 0x0a, 0x08, 0xe4, 0xde, 0x3b, 0x00, 0x8f, 0xeb, 0x98, + 0x51, 0x95, 0x99, 0xe0, 0x35, 0x5d, 0x0f, 0x2d, 0xee, 0x49, 0x4a, 0x59, 0x9d, + 0xe9, 0xef, 0xeb, 0xfd, 0x76, 0xcb, 0x7a, 0xec, 0x77, 0xa6, 0x70, 0x87, 0xc5, + 0xec, 0x44, 0x57, 0x79, 0xc3, 0xa2, 0xce, 0xc1, 0x18, + ], + [ + 0xa4, 0xd0, 0x67, 0x30, 0x6c, 0x32, 0xde, 0xbe, 0x21, 0x8c, 0xb6, 0x01, 0x3b, + 0xe8, 0xa0, 0xc5, 0xa7, 0xff, 0xf6, 0xcd, 0x35, 0x79, 0x95, 0x2e, 0xc6, 0xda, + 0x9b, 0x70, 0x80, 0x1e, 0x07, 0xdb, 0x13, 0x28, 0x93, 0x0e, 0xa0, 0x26, 0x3c, + 0x7e, 0x86, 0x6b, 0x45, 0xb9, 0x38, 0x99, 0xd8, 0x38, 0x54, 0xc9, 0x5e, 0x35, + 0x47, 0xc0, 0xc0, 0x44, 0x46, 0x94, 0xf9, 0x3b, 0xf4, 0xbe, 0xe1, 0x89, + ] + ), + test_case!( + [ + 0x4f, 0xd4, 0x06, 0x82, 0x8c, 0xe3, 0x8c, 0x86, 0x93, 0x63, 0x24, 0x0e, 0xac, + 0xa1, 0xe0, 0xb3, 0xf1, 0x5f, 0x10, 0xa5, 0x30, 0x51, 0xed, 0xfe, 0xed, 0x66, + 0x07, 0x71, 0x8f, 0x18, 0x0c, 0x8b, 0x53, 0xc1, 0x5e, 0xec, 0xd2, 0xa0, 0x32, + 0x1b, 0x5e, 0xb6, 0x9b, 0x06, 0xd3, 0xf4, 0x7f, 0xf3, 0xcd, 0xc4, 0x1f, 0x39, + 0x4c, 0x2b, 0xf1, 0xfc, 0x00, 0x0b, 0xf1, 0x65, 0x0e, 0x81, 0x41, 0x08, 0x9a, + 0x57, 0xa4, 0x93, 0x33, 0x1e, 0xac, 0x42, 0x14, 0xe3, 0xc9, 0x2e, 0x84, 0x7a, + 0xaa, 0x2e, 0x5d, 0x24, 0x62, 0xd6, 0x42, 0xd5, 0x72, 0xb7, 0x75, 0xe5, 0x90, + 0xc5, 0x3a, 0x43, 0xb7, + ], + [ + 0x02, 0x23, 0xd7, 0x82, 0xd3, 0xbc, 0x1a, 0x71, 0x64, 0x73, 0xb6, 0x0c, 0xba, + 0x06, 0x42, 0x38, 0x41, 0x89, 0xb4, 0x87, + ], + [ + 0xd5, 0x62, 0xb6, 0x1c, 0xc5, 0xaa, 0x4d, 0xd6, 0x82, 0xb8, 0x9f, 0xd4, 0xa4, + 0x21, 0xdd, 0x98, 0xdc, 0x04, 0x2e, 0x64, 0xb1, 0x05, 0xe3, 0xfd, 0x4f, 0xa0, + 0x8e, 0x0c, 0x30, 0x2e, 0x45, 0xe2, + ], + [ + 0x46, 0xb2, 0x59, 0x57, 0x65, 0xff, 0x15, 0xaf, 0xf3, 0x6f, 0xc6, 0xc5, 0x5f, + 0x6c, 0x8a, 0xbc, 0xc8, 0xbe, 0x73, 0x4b, 0xab, 0x22, 0xff, 0x07, 0xb4, 0x84, + 0x0e, 0x94, 0x5c, 0x99, 0x37, 0xa0, 0xa6, 0xdc, 0x6e, 0xef, 0xb6, 0x11, 0xf4, + 0x57, 0x38, 0x0e, 0xeb, 0x6a, 0x75, 0x62, 0xdd, 0x36, + ], + [ + 0x35, 0x70, 0x74, 0xd9, 0x81, 0xb9, 0xaa, 0x7d, 0x1d, 0xb3, 0x59, 0x5f, 0x24, + 0x2c, 0xe5, 0xb8, 0xe3, 0xf1, 0x3c, 0x28, 0x2f, 0x00, 0x3c, 0xcc, 0x31, 0x8e, + 0x0f, 0x7e, 0xc9, 0xf0, 0xf4, 0x33, 0x74, 0xc4, 0x9d, 0x8f, 0xa5, 0x9a, 0x57, + 0xae, 0x9b, 0xb5, 0xc9, 0x60, 0x87, 0xdd, 0xb8, 0x4b, 0x75, 0xb9, 0x43, 0xd0, + 0x72, 0x68, 0xd3, 0xf9, 0x82, 0x23, 0xba, 0x8d, 0xf6, 0xc3, 0x05, 0x3a, + ] + ), + test_case!( + [ + 0x32, 0xac, 0x0f, 0x42, 0x50, 0x87, 0xb6, 0x4d, 0x46, 0x68, 0xfc, 0xe9, 0x04, + 0x51, 0xe7, 0x72, 0x6b, 0x63, 0x33, 0x37, 0x7c, 0x0c, 0xd1, 0xd2, 0x93, 0x8a, + 0x11, 0xab, 0x96, 0x98, 0xbe, 0x7d, 0xd4, 0x22, 0xb1, 0x69, 0xd3, 0x1b, 0x3f, + 0x17, 0x3a, 0x7f, 0x96, 0x71, 0x82, 0xe4, 0x71, 0xd2, 0x36, 0x04, 0x8d, 0xc1, + 0x27, 0xb2, 0xbb, 0x80, 0xb7, 0xf2, 0x82, 0xfe, 0x9e, 0xa3, 0x9b, 0xc9, 0xda, + 0xa5, 0x61, 0x40, 0x1e, 0xdc, 0xd2, 0x3f, 0x17, 0xb2, 0x4a, 0xa2, 0x86, 0x5b, + 0x1e, 0x6f, 0xfa, 0x2f, 0x80, 0x9c, 0xe0, 0xc1, 0x3f, 0x00, 0x36, 0xbd, 0x3b, + 0x01, 0xf4, 0xe6, 0x7e, 0x74, + ], + [ + 0x84, 0x27, 0xdf, 0xa6, 0x8c, 0x10, 0xdd, 0x14, 0x8b, 0x90, 0xb2, 0x74, 0xbc, + 0x54, 0xee, 0x7b, 0x93, 0x06, 0xda, 0x0b, + ], + [ + 0xeb, 0x4f, 0x8d, 0x22, 0xdb, 0x7d, 0x47, 0xd7, 0x8c, 0x8d, 0xfc, 0x4a, 0x74, + 0x62, 0xcc, 0x95, 0xb3, 0x04, 0xfa, 0x51, 0x08, 0xfa, 0x54, 0x34, 0xcb, 0x6c, + 0x87, 0xe5, 0x58, 0x8b, 0xcc, 0x7f, + ], + [ + 0x70, 0x1d, 0x91, 0x59, 0xbc, 0xd6, 0xdd, 0xa7, 0xc5, 0xd6, 0xc4, 0x1d, 0xeb, + 0x4b, 0xd9, 0x5d, 0xc9, 0x62, 0xb2, 0x7b, 0x2b, 0xce, 0xd2, 0x7f, 0x3a, 0x4c, + 0x0a, 0xd9, 0x7a, 0x90, 0xef, 0x9b, 0x80, 0x89, 0xd2, 0xed, 0x0d, 0x37, 0xbd, + 0x3e, 0x26, 0x1d, 0x10, 0x87, 0xac, 0x72, 0xaa, 0x2b, + ], + [ + 0x3d, 0x7e, 0xc4, 0x53, 0xd4, 0x22, 0xcd, 0xcb, 0x43, 0xd6, 0x1f, 0xce, 0xab, + 0xbd, 0x40, 0xbf, 0x90, 0x69, 0xa3, 0x26, 0x72, 0x3f, 0xdb, 0xb3, 0x94, 0x4d, + 0x0f, 0x21, 0x20, 0xd2, 0x28, 0x35, 0x94, 0x69, 0xf0, 0xac, 0xba, 0xd2, 0xb6, + 0xb0, 0xeb, 0x34, 0x8f, 0x5e, 0x80, 0x0d, 0xf8, 0x71, 0x03, 0x0d, 0x3b, 0x42, + 0xac, 0x66, 0x2e, 0xc6, 0xac, 0x5a, 0x6c, 0xc1, 0x0c, 0x3f, 0x07, 0xb7, + ] + ), + test_case!( + [ + 0xdf, 0xcd, 0x4f, 0x4c, 0x0b, 0x6a, 0x78, 0x2b, 0xe5, 0xda, 0x7d, 0x9e, 0x79, + 0xeb, 0x73, 0x7c, 0x4c, 0x84, 0xae, 0xf1, 0x5e, 0x90, 0xd1, 0xd1, 0xa6, 0x6a, + 0x3b, 0xc0, 0x43, 0x77, 0x64, 0x6c, 0x25, 0xd7, 0x04, 0x71, 0xc6, 0xf0, 0x89, + 0xbf, 0x22, 0x7b, 0xa6, 0x3e, 0x37, 0xad, 0xd5, 0xc6, 0xd1, 0xb4, 0xf3, 0x75, + 0x44, 0xda, 0xa7, 0xf4, 0x90, 0xea, 0xc2, 0xf6, 0x5c, 0x24, 0xab, 0xa0, 0xed, + 0x08, 0xe4, 0xf7, 0x9b, 0xb1, 0xc8, 0x8d, 0x9d, 0x81, 0x2d, 0x90, 0x57, 0x89, + 0x74, 0x4c, 0x66, 0xbd, 0x8e, 0xd2, 0x99, 0x2a, 0x11, 0x2a, 0x6e, 0xf6, 0x12, + 0x2f, 0xf3, 0x75, 0xee, 0x48, 0xd3, + ], + [ + 0xf9, 0x60, 0xa4, 0x5e, 0xc2, 0x4a, 0xfc, 0xee, 0xd5, 0x91, 0xf8, 0x83, 0x0c, + 0x99, 0xa8, 0x5d, 0xd6, 0x08, 0x10, 0xd3, + ], + [ + 0xe7, 0xbf, 0xf6, 0xb7, 0xd9, 0x6d, 0x92, 0x7d, 0x20, 0xa7, 0x15, 0x4e, 0x60, + 0x68, 0x22, 0x4f, 0x9f, 0x9a, 0x87, 0x0e, 0x72, 0x0c, 0x9a, 0x7e, 0x19, 0xda, + 0x6f, 0x80, 0x86, 0x09, 0x14, 0x19, + ], + [ + 0x5c, 0x9c, 0xed, 0xdd, 0x66, 0xa7, 0x10, 0x8a, 0x9d, 0x5c, 0x7d, 0x84, 0xbb, + 0x69, 0x12, 0x23, 0xb1, 0xbf, 0xd0, 0x13, 0xa8, 0xc8, 0x97, 0x12, 0x3b, 0x73, + 0xeb, 0x82, 0xea, 0xd1, 0x06, 0xb3, 0xb7, 0x62, 0xc4, 0xc4, 0x5e, 0xd4, 0xcb, + 0xd2, 0x07, 0x61, 0x8f, 0xbf, 0x8d, 0x69, 0x35, 0xf8, + ], + [ + 0x52, 0x40, 0xa2, 0xf5, 0xa2, 0x90, 0x47, 0xc7, 0xaa, 0x86, 0x80, 0x2b, 0x84, + 0x29, 0x99, 0x33, 0x96, 0x7c, 0xf8, 0xc7, 0xef, 0xe3, 0x4d, 0x89, 0x57, 0xd7, + 0xe7, 0xc9, 0xd7, 0xe1, 0x7d, 0xbc, 0x71, 0xb6, 0x13, 0x1b, 0x50, 0x3a, 0x2a, + 0x0a, 0xcf, 0x60, 0x02, 0x34, 0x62, 0xdf, 0x22, 0xe1, 0x1a, 0xd9, 0xa5, 0x8d, + 0x7d, 0xa6, 0xea, 0xb9, 0x0e, 0x38, 0xa6, 0xdc, 0xe0, 0x9e, 0x82, 0xb4, + ] + ), + test_case!( + [ + 0xcb, 0x50, 0x7c, 0x8b, 0x3c, 0x2d, 0x89, 0xbb, 0x93, 0xf3, 0xe6, 0xee, 0xd4, + 0x53, 0x13, 0xa1, 0xeb, 0xb6, 0x3f, 0x76, 0x01, 0x90, 0xda, 0x57, 0x32, 0x73, + 0xa3, 0x12, 0x0a, 0xd4, 0x09, 0x6e, 0x14, 0xd7, 0x7d, 0xb4, 0xfe, 0xc4, 0x09, + 0x9d, 0x06, 0x9d, 0xe9, 0xb8, 0xf8, 0xce, 0x12, 0xe6, 0xf2, 0x5d, 0x36, 0x1d, + 0x3d, 0xf3, 0x4b, 0x74, 0x7e, 0xfa, 0xbf, 0x41, 0x41, 0xa6, 0x82, 0xf2, 0x21, + 0x25, 0x99, 0xf8, 0x03, 0xaa, 0x4d, 0x3d, 0x08, 0x61, 0x5c, 0xb8, 0x40, 0x6c, + 0xc8, 0xda, 0x53, 0x69, 0xe4, 0xb3, 0xbb, 0x7c, 0x30, 0x41, 0x16, 0x87, 0xee, + 0x55, 0x7d, 0xe3, 0xfc, 0x4e, 0x8e, 0x7f, + ], + [ + 0xdf, 0xfe, 0x3c, 0x28, 0x51, 0xd1, 0x81, 0x34, 0x7d, 0x83, 0x22, 0x65, 0xfb, + 0xbb, 0x75, 0x70, 0x36, 0x63, 0x2e, 0xb4, + ], + [ + 0x2c, 0x68, 0x29, 0x0f, 0x2e, 0xe7, 0xe0, 0x95, 0x4e, 0x0a, 0xbf, 0x48, 0x05, + 0x9c, 0xd4, 0x99, 0x68, 0xdf, 0x1f, 0x5f, 0x08, 0xb4, 0xa8, 0x3b, 0x44, 0xf3, + 0x24, 0xfd, 0x86, 0x08, 0xa9, 0x1b, + ], + [ + 0xe2, 0x21, 0xb1, 0x6d, 0xfc, 0x5a, 0x4d, 0xd2, 0xac, 0xa0, 0xcf, 0xae, 0xc6, + 0x6a, 0x88, 0xcd, 0xe5, 0x27, 0x14, 0xa7, 0xed, 0x3b, 0x8a, 0x12, 0x2a, 0xa9, + 0x21, 0xec, 0x71, 0x28, 0xc9, 0xf0, 0x24, 0xe8, 0xc2, 0x43, 0x90, 0xb1, 0xbc, + 0xd8, 0xd4, 0x0c, 0xdd, 0x15, 0x6f, 0xab, 0x1c, 0x99, + ], + [ + 0x6f, 0xac, 0x6c, 0xc0, 0x70, 0xe7, 0x48, 0x9a, 0xd9, 0x37, 0xec, 0x29, 0xb9, + 0xe0, 0x56, 0x45, 0x5f, 0xe0, 0xf9, 0xfc, 0x1d, 0x13, 0x24, 0xd2, 0xca, 0x85, + 0x4f, 0x3e, 0x47, 0x4c, 0xd8, 0x0d, 0x22, 0x56, 0x5d, 0xea, 0x9e, 0xf2, 0x6c, + 0xc3, 0x9a, 0x41, 0x9e, 0xf7, 0xbe, 0x7a, 0x20, 0x45, 0x51, 0x00, 0x6d, 0x76, + 0x2a, 0x80, 0x96, 0x00, 0xb6, 0xe8, 0x41, 0xfa, 0xcc, 0xe1, 0x72, 0xb5, + ] + ), + test_case!( + [ + 0x17, 0x3e, 0x54, 0xa8, 0x59, 0x6f, 0xad, 0x91, 0xd0, 0x43, 0x82, 0x36, 0xd4, + 0x21, 0xd1, 0x6c, 0x90, 0x12, 0x57, 0x86, 0xf2, 0x5d, 0x6c, 0x56, 0x05, 0xf6, + 0x88, 0xf6, 0x8a, 0xe1, 0x59, 0x4f, 0x16, 0x6d, 0xb0, 0xdb, 0x01, 0xbd, 0x61, + 0x75, 0x86, 0x49, 0xc1, 0x85, 0xa1, 0xcb, 0xb0, 0x3a, 0x55, 0xa3, 0x6f, 0xb9, + 0x86, 0xf4, 0xd8, 0xaf, 0xc9, 0x98, 0xf0, 0x25, 0x5b, 0xc1, 0x78, 0x58, 0x18, + 0x42, 0xae, 0x1d, 0xd2, 0x75, 0xac, 0xe9, 0x15, 0x5f, 0x4e, 0x68, 0xe4, 0x58, + 0x22, 0x66, 0x42, 0x68, 0x98, 0xaa, 0x04, 0xa3, 0x89, 0x24, 0xbd, 0xdd, 0x06, + 0xa9, 0x8c, 0x06, 0x74, 0xe4, 0x32, 0x74, 0xf1, + ], + [ + 0x9e, 0x1f, 0x91, 0xda, 0x68, 0x85, 0xf7, 0xa1, 0x18, 0x88, 0x66, 0x71, 0x0d, + 0xfd, 0x87, 0xd7, 0x22, 0xc2, 0xf0, 0x58, + ], + [ + 0x6f, 0x06, 0x6d, 0xd5, 0xe8, 0x07, 0xbd, 0x8e, 0xfa, 0xb0, 0x1a, 0x2e, 0xce, + 0x00, 0x30, 0x52, 0x62, 0xf6, 0xc8, 0xab, 0xfc, 0xdb, 0xd8, 0xae, 0xb4, 0x95, + 0x15, 0x9f, 0x87, 0xf8, 0x5b, 0x92, + ], + [ + 0x79, 0x99, 0x0a, 0x40, 0x88, 0xe5, 0x88, 0xe6, 0x94, 0x58, 0x76, 0xe4, 0x08, + 0x6e, 0x12, 0x20, 0xe5, 0x23, 0xf3, 0x43, 0xa8, 0x12, 0xee, 0xf0, 0xa1, 0x2e, + 0xc4, 0xc7, 0x0e, 0xf3, 0x05, 0xbf, 0x16, 0xac, 0xf7, 0x41, 0x52, 0xa9, 0x94, + 0x4c, 0xac, 0x68, 0xcb, 0x42, 0x6d, 0x81, 0x3a, 0xdf, + ], + [ + 0xe5, 0xf4, 0x45, 0xba, 0xaa, 0x0e, 0x51, 0x2f, 0x3d, 0x1f, 0x9b, 0x23, 0x5b, + 0x7c, 0xb3, 0xf2, 0x20, 0x1e, 0x70, 0x2a, 0x30, 0x7c, 0x14, 0x1a, 0x26, 0x07, + 0x7f, 0x8d, 0xed, 0x4c, 0x9a, 0x7b, 0xbd, 0x3d, 0x96, 0x8e, 0x86, 0x99, 0xec, + 0xac, 0x70, 0xf1, 0x38, 0xef, 0xb3, 0x37, 0x8f, 0x20, 0xf9, 0x78, 0x4b, 0xcf, + 0xef, 0x4e, 0x67, 0x03, 0x96, 0x3d, 0x50, 0x39, 0x15, 0xa5, 0xc5, 0x43, + ] + ), + test_case!( + [ + 0x95, 0x16, 0x49, 0xb0, 0x8b, 0x66, 0xb9, 0xdf, 0x54, 0x27, 0xec, 0x3f, 0xa1, + 0xcb, 0xf5, 0x74, 0x13, 0x7d, 0x85, 0xcc, 0xc4, 0xab, 0xea, 0x3c, 0xad, 0x93, + 0x66, 0xe6, 0xe3, 0xf4, 0x6b, 0x70, 0x13, 0xa6, 0xed, 0xdb, 0xd3, 0xdb, 0x6d, + 0x1a, 0x7b, 0xbc, 0x3f, 0x93, 0xe7, 0xd3, 0xbc, 0xb3, 0x2e, 0xa8, 0xb5, 0x26, + 0xdd, 0xd4, 0x8a, 0x01, 0x11, 0x02, 0xfe, 0x39, 0xf3, 0x44, 0xc6, 0xe9, 0x01, + 0xf2, 0x19, 0x73, 0x57, 0x29, 0x84, 0x50, 0x4b, 0x63, 0x18, 0xcd, 0xf8, 0xfe, + 0x24, 0xbd, 0x40, 0x9f, 0x9f, 0xad, 0x29, 0x23, 0xd9, 0x9d, 0xb1, 0x38, 0x19, + 0x68, 0x1b, 0x56, 0x5f, 0xb0, 0xe7, 0x00, 0x9d, 0x28, + ], + [ + 0x6c, 0x92, 0x43, 0xc3, 0xc9, 0xb4, 0x0f, 0xbb, 0x7e, 0x2b, 0xd9, 0x46, 0x52, + 0x87, 0x9a, 0x8b, 0xfe, 0x19, 0x20, 0x01, + ], + [ + 0x26, 0x2b, 0x4e, 0x0a, 0xc3, 0xbe, 0x32, 0xe6, 0xf3, 0x3f, 0xf4, 0x77, 0x38, + 0x5d, 0xa8, 0x59, 0xf6, 0xff, 0xcb, 0x4a, 0x44, 0x0b, 0x02, 0x25, 0x58, 0x76, + 0xce, 0x94, 0xfc, 0xad, 0xe1, 0xa4, + ], + [ + 0x35, 0xba, 0x1b, 0x0a, 0x8a, 0x1d, 0x2a, 0x23, 0x97, 0x3a, 0x77, 0x79, 0x63, + 0xa9, 0x28, 0xd7, 0xbd, 0xdc, 0x14, 0xd5, 0x33, 0x40, 0xd0, 0xd1, 0x42, 0x6e, + 0x85, 0x6a, 0xc4, 0x25, 0x75, 0xe3, 0xf9, 0x9b, 0x14, 0xba, 0xbb, 0x8b, 0x02, + 0x1d, 0x84, 0x95, 0x2a, 0x73, 0xec, 0x32, 0xc5, 0xfa, + ], + [ + 0xa6, 0xb8, 0x42, 0xde, 0xae, 0xb0, 0xc1, 0x83, 0x02, 0x30, 0x93, 0xbd, 0x33, + 0xf0, 0x0e, 0x4a, 0x77, 0x2e, 0x1d, 0xd8, 0x0a, 0x8d, 0x06, 0xeb, 0x51, 0x58, + 0xc7, 0x4c, 0x62, 0x7f, 0x64, 0x53, 0xf2, 0x4b, 0xa3, 0x05, 0xfe, 0xd8, 0xf5, + 0x07, 0xd7, 0x37, 0xbb, 0x79, 0x9b, 0xce, 0xc5, 0xde, 0xff, 0x53, 0x45, 0x71, + 0x42, 0xd6, 0x5d, 0x74, 0x7a, 0x34, 0x06, 0x65, 0x20, 0x48, 0xe4, 0xd8, + ] + ), + test_case!( + [ + 0xf2, 0x6c, 0x71, 0xc0, 0xb3, 0x38, 0x23, 0x77, 0x86, 0xb9, 0xb1, 0x73, 0x37, + 0x85, 0x2d, 0x57, 0x21, 0xb1, 0xfd, 0x8b, 0x3d, 0x39, 0xb0, 0xbd, 0x63, 0x5b, + 0xe2, 0x70, 0x6d, 0x44, 0x8b, 0x5a, 0xc9, 0x41, 0xc3, 0xc5, 0x31, 0x2c, 0xbe, + 0x88, 0x00, 0x96, 0x1c, 0x9a, 0x17, 0x8a, 0x39, 0x1b, 0x79, 0xf2, 0x0b, 0x39, + 0x1b, 0xa0, 0x90, 0xd8, 0x3f, 0xeb, 0xa8, 0x4a, 0xe1, 0x2f, 0x9e, 0x6a, 0x46, + 0x3b, 0xde, 0xe6, 0xdc, 0x3e, 0xd9, 0xd7, 0x92, 0x04, 0xe0, 0xe7, 0x0e, 0xea, + 0xea, 0x1e, 0x93, 0x0f, 0x32, 0x42, 0x4e, 0x4d, 0x69, 0x29, 0x78, 0x73, 0xf9, + 0xf1, 0x6c, 0x97, 0x09, 0x93, 0x23, 0xf2, 0x30, 0xab, 0x97, + ], + [ + 0xae, 0xc0, 0x80, 0x77, 0x14, 0x2e, 0x6f, 0xcb, 0x6a, 0x79, 0xda, 0x28, 0x6c, + 0xd6, 0x0b, 0xd6, 0xb0, 0xc2, 0x3b, 0xc7, + ], + [ + 0x23, 0x4d, 0x9d, 0x0c, 0xd3, 0x62, 0xc3, 0x7f, 0xf0, 0x81, 0x22, 0xee, 0x16, + 0xc9, 0x64, 0xf1, 0x06, 0xd8, 0x7b, 0x89, 0xf1, 0xb3, 0x8f, 0xa4, 0xde, 0x2d, + 0x1f, 0x83, 0xbd, 0x62, 0xff, 0x79, + ], + [ + 0x1b, 0x2b, 0xcf, 0x3c, 0xe1, 0x1a, 0xc3, 0x3f, 0x46, 0x54, 0x81, 0xda, 0xea, + 0xc3, 0x13, 0x3b, 0x0d, 0x9d, 0x43, 0x77, 0x97, 0x3e, 0xe4, 0x61, 0x84, 0xad, + 0x55, 0x82, 0xe3, 0xa5, 0xea, 0xb6, 0x44, 0xf8, 0x52, 0x8d, 0xec, 0x64, 0x06, + 0x21, 0x47, 0x79, 0x6c, 0x65, 0x51, 0xeb, 0xa5, 0xaa, + ], + [ + 0x07, 0xdb, 0x67, 0x19, 0xaa, 0x67, 0x3b, 0xe8, 0x22, 0xb6, 0x94, 0x66, 0x91, + 0x13, 0x58, 0x68, 0x0a, 0x90, 0x02, 0x4b, 0x86, 0x8b, 0x67, 0x81, 0x9d, 0xef, + 0xd6, 0x58, 0xc1, 0xb4, 0x43, 0x21, 0xfd, 0x01, 0x7b, 0x32, 0x60, 0x4d, 0x51, + 0x88, 0x0f, 0xf3, 0x52, 0x12, 0xca, 0x16, 0xd9, 0xfd, 0xb7, 0x32, 0x34, 0x5d, + 0x60, 0x23, 0x10, 0xbc, 0x11, 0xa3, 0x14, 0x4c, 0x96, 0x02, 0x22, 0xc8, + ] + ), + test_case!( + [ + 0xb8, 0x4e, 0x8a, 0x14, 0x6c, 0x66, 0x13, 0x9d, 0x94, 0x1f, 0xe7, 0x0e, 0xc9, + 0xf4, 0xbe, 0x6e, 0x74, 0x3c, 0xaa, 0x1b, 0x02, 0x28, 0x15, 0xd9, 0xfb, 0x7e, + 0xee, 0xd9, 0x35, 0xc9, 0xd7, 0x2d, 0x0c, 0xa0, 0xb5, 0x7d, 0xf4, 0x9d, 0x39, + 0x3f, 0x51, 0xf0, 0x0b, 0x49, 0x65, 0xc5, 0x24, 0x21, 0xd4, 0x18, 0xa3, 0x80, + 0xcb, 0x1f, 0x86, 0x2a, 0x7f, 0x30, 0x9c, 0x86, 0x4e, 0x3e, 0x0f, 0xee, 0x8a, + 0x2e, 0x86, 0x22, 0x3c, 0xa2, 0x4a, 0xb0, 0x3f, 0xa0, 0x38, 0x91, 0x0f, 0x30, + 0x02, 0xed, 0x82, 0xb8, 0x24, 0xfc, 0x43, 0xf3, 0x3b, 0x5f, 0x1f, 0x43, 0xf0, + 0x44, 0x07, 0xd3, 0x9e, 0xd3, 0x27, 0x65, 0xa8, 0x76, 0x9e, 0x9c, + ], + [ + 0x81, 0xc3, 0x45, 0xbf, 0xd7, 0xf9, 0xbb, 0x4b, 0x1f, 0x7a, 0xff, 0x58, 0x33, + 0x0a, 0x7c, 0x98, 0x25, 0x67, 0x40, 0xa4, + ], + [ + 0xc8, 0xfd, 0x96, 0x57, 0xab, 0x18, 0x60, 0xf1, 0xca, 0xfe, 0x10, 0x54, 0x05, + 0x54, 0x07, 0xa9, 0x52, 0x03, 0x59, 0x94, 0x13, 0x26, 0x94, 0x8e, 0x79, 0x82, + 0xf4, 0xe6, 0xb8, 0x1f, 0x0c, 0xc5, + ], + [ + 0x69, 0x6b, 0xf9, 0x28, 0x4a, 0x94, 0x27, 0x46, 0xf2, 0xc0, 0x98, 0xdb, 0x8d, + 0x7b, 0x9e, 0xe1, 0x90, 0x5f, 0xfc, 0x0f, 0xef, 0xe4, 0xa7, 0x5e, 0x99, 0xb8, + 0x92, 0xd8, 0x99, 0xcc, 0xdd, 0x38, 0xc1, 0xcf, 0x06, 0x00, 0x8e, 0x53, 0xb6, + 0xf6, 0x2d, 0xcf, 0xfb, 0xdc, 0x5b, 0xf5, 0x0e, 0xe3, + ], + [ + 0x27, 0x8d, 0x60, 0x38, 0xee, 0xa1, 0x65, 0x8d, 0x45, 0x38, 0xd8, 0xf6, 0x9a, + 0x0d, 0x75, 0x07, 0xae, 0x39, 0x18, 0x29, 0xff, 0x87, 0x81, 0xb0, 0x57, 0x6f, + 0x11, 0x16, 0x17, 0xe1, 0xd0, 0xce, 0xcf, 0x09, 0xdb, 0xa4, 0xc8, 0x1d, 0xb8, + 0xba, 0xfa, 0x9d, 0xd0, 0xae, 0x1e, 0x19, 0xd6, 0x7a, 0x5a, 0x94, 0x58, 0x0c, + 0x89, 0xd8, 0xbb, 0xf3, 0xdc, 0x0d, 0x81, 0x38, 0x84, 0x08, 0xbc, 0x10, + ] + ), + test_case!( + [ + 0x34, 0xfe, 0xcd, 0xb5, 0xe3, 0xb9, 0x02, 0x69, 0x78, 0x73, 0x4c, 0x24, 0xdb, + 0x6a, 0x47, 0xb9, 0xca, 0x9a, 0x2e, 0x37, 0xc6, 0xa5, 0x6b, 0xbe, 0x70, 0x01, + 0xf3, 0x24, 0x0a, 0xb2, 0xf2, 0x12, 0x1a, 0x7c, 0x51, 0xe7, 0x2b, 0x93, 0x5d, + 0xb5, 0xaf, 0xca, 0x12, 0x21, 0x6b, 0x4a, 0x29, 0x92, 0x2a, 0xe9, 0x84, 0x22, + 0x51, 0x5c, 0x4b, 0xf9, 0x93, 0x8c, 0xa4, 0xf9, 0x38, 0x27, 0x1d, 0x5a, 0xa5, + 0x6a, 0x8e, 0x9e, 0xb2, 0x18, 0xd0, 0xb6, 0x65, 0x2c, 0xea, 0x64, 0xbb, 0x5f, + 0x98, 0x6f, 0x5d, 0x17, 0xd5, 0x4b, 0x7b, 0xc7, 0x15, 0xb8, 0xfd, 0x99, 0x9e, + 0x31, 0x18, 0x4f, 0x1f, 0xb0, 0x54, 0x0b, 0xb6, 0x23, 0x4c, 0xad, 0x4d, + ], + [ + 0x4d, 0xcb, 0x60, 0x4e, 0x5d, 0xf3, 0x75, 0x0d, 0x4a, 0x82, 0x2f, 0x0c, 0xc3, + 0x9f, 0x21, 0xea, 0xd8, 0xc3, 0x7d, 0xc3, + ], + [ + 0xba, 0x2a, 0xd0, 0x06, 0xa5, 0xcb, 0x40, 0xab, 0xbc, 0xda, 0x10, 0xa8, 0x7c, + 0xf1, 0xca, 0xf8, 0xaa, 0x45, 0x11, 0x57, 0x3f, 0xab, 0x13, 0xdf, 0xe8, 0xa2, + 0x62, 0x38, 0xcd, 0x66, 0x80, 0x2f, + ], + [ + 0x1d, 0x34, 0xbb, 0x19, 0x32, 0xe8, 0x77, 0xbf, 0x4c, 0x5b, 0x98, 0xab, 0x2d, + 0x54, 0x51, 0x0d, 0xde, 0x8c, 0x3f, 0x29, 0x03, 0x73, 0x10, 0x29, 0x65, 0xbc, + 0xe9, 0xd9, 0x67, 0x05, 0xb0, 0x8c, 0x2f, 0xf3, 0xe6, 0x34, 0x93, 0x9b, 0x43, + 0x50, 0x72, 0x74, 0x78, 0x30, 0x5a, 0x40, 0xd3, 0xb5, + ], + [ + 0xac, 0xe5, 0xbe, 0xfd, 0x98, 0xa7, 0x7b, 0x12, 0xcf, 0x16, 0xa2, 0xec, 0x8e, + 0x6a, 0x75, 0x9a, 0x35, 0x8b, 0x1b, 0xab, 0x34, 0xc1, 0xb1, 0xd0, 0x02, 0x6b, + 0x6d, 0x8d, 0xff, 0x12, 0x92, 0xf0, 0x31, 0x7b, 0xdf, 0x2d, 0x2d, 0x1d, 0xb6, + 0x68, 0x56, 0x06, 0x5a, 0xcb, 0xf4, 0x54, 0x9d, 0x58, 0x61, 0xd6, 0x01, 0x05, + 0x32, 0x51, 0x1d, 0x4c, 0x7d, 0xb5, 0xbf, 0xbb, 0x7a, 0xf0, 0x95, 0x27, + ] + ), + test_case!( + [ + 0xaf, 0x1f, 0x29, 0x3d, 0xb6, 0xdf, 0x72, 0x86, 0x8c, 0xcc, 0x90, 0x69, 0x0a, + 0x9b, 0x89, 0x80, 0xe7, 0xfa, 0xdc, 0xf1, 0x59, 0x19, 0xe2, 0xf5, 0xc6, 0x59, + 0xf6, 0xca, 0xc8, 0xa3, 0x75, 0x82, 0x11, 0x04, 0x45, 0x90, 0xae, 0xfc, 0xbb, + 0x23, 0x5e, 0xc4, 0x0f, 0x90, 0x7c, 0x9e, 0x19, 0xcf, 0x0a, 0x38, 0x55, 0x54, + 0x7e, 0xa2, 0xf4, 0x02, 0x8a, 0x6f, 0xb7, 0xda, 0xd8, 0x5a, 0x4a, 0x5d, 0x39, + 0xf0, 0xd2, 0x7d, 0xc0, 0x7d, 0xd9, 0xc0, 0x6a, 0x92, 0x15, 0x74, 0xbb, 0xa5, + 0x45, 0x2e, 0x91, 0x73, 0x7f, 0xef, 0x4a, 0xe7, 0x9a, 0x70, 0xa8, 0xb0, 0x6f, + 0x3c, 0x0e, 0x49, 0xbc, 0xd7, 0x72, 0xf9, 0xbe, 0x3a, 0xc3, 0xf1, 0x67, 0x1a, + ], + [ + 0xf8, 0x13, 0xff, 0x91, 0x6c, 0x8a, 0xd3, 0xc0, 0x87, 0x4f, 0x54, 0x9d, 0xae, + 0x1f, 0x87, 0xf1, 0x51, 0x00, 0xc8, 0x89, + ], + [ + 0x5f, 0x22, 0x70, 0x31, 0x1f, 0xf1, 0x75, 0x94, 0xd3, 0xaa, 0xe0, 0x90, 0xf6, + 0x73, 0x75, 0x01, 0xcf, 0x9b, 0xcc, 0xb4, 0x17, 0x39, 0x61, 0x4f, 0x4f, 0x0f, + 0x79, 0x42, 0xe9, 0x34, 0x8e, 0x30, + ], + [ + 0x8a, 0x13, 0xf4, 0xd5, 0xf5, 0x49, 0x28, 0xe0, 0x7c, 0x8b, 0xa5, 0xf0, 0x76, + 0x05, 0x6d, 0x4e, 0x71, 0x80, 0x04, 0x88, 0x4f, 0x08, 0x35, 0x24, 0xce, 0xcd, + 0x50, 0x4e, 0xad, 0x92, 0x79, 0xe9, 0xbc, 0xad, 0xc4, 0x19, 0x9a, 0xf1, 0x03, + 0x78, 0x4f, 0xac, 0xfb, 0x95, 0x30, 0x18, 0x5e, 0x1b, + ], + [ + 0x76, 0x4b, 0x82, 0xe8, 0xaa, 0x93, 0x07, 0x60, 0xfc, 0x1f, 0xd4, 0x56, 0x0b, + 0xd3, 0x1b, 0x0c, 0xe9, 0x77, 0x71, 0x13, 0xa4, 0x08, 0xb2, 0x6b, 0xb8, 0x0c, + 0xc2, 0xaf, 0x04, 0xaf, 0xbf, 0xfc, 0xdd, 0xf8, 0x44, 0x71, 0xc7, 0x54, 0x64, + 0x23, 0xa0, 0xaa, 0xc3, 0x65, 0x9f, 0x80, 0x1c, 0x7a, 0x99, 0x8d, 0x10, 0x4a, + 0xe2, 0xaf, 0x08, 0xb5, 0x51, 0x03, 0x18, 0xd9, 0x38, 0x54, 0x16, 0x0f, + ] + ), + test_case!( + [ + 0x24, 0xbe, 0x49, 0x7a, 0x0f, 0x94, 0xef, 0x6e, 0x5a, 0x59, 0xf4, 0x22, 0xd2, + 0x27, 0x53, 0x71, 0xc8, 0x8b, 0x9b, 0x38, 0xb9, 0x97, 0x00, 0x6c, 0x42, 0x69, + 0x99, 0xb7, 0xf6, 0x35, 0x72, 0xcb, 0x1b, 0xce, 0xbb, 0x87, 0x7a, 0xde, 0xb0, + 0x13, 0xa3, 0xf5, 0x6b, 0x8d, 0x80, 0xc6, 0x96, 0x6e, 0x9f, 0xcf, 0xb9, 0x2a, + 0xda, 0xcf, 0xfd, 0xd7, 0x42, 0x0e, 0x74, 0xaf, 0xd2, 0x03, 0x34, 0x11, 0xe8, + 0x50, 0x23, 0xc8, 0xca, 0xf2, 0xaf, 0xf6, 0x9f, 0xe8, 0x38, 0x51, 0xa2, 0x7b, + 0xe1, 0xec, 0x90, 0x5b, 0x9e, 0xe4, 0xd9, 0x09, 0x53, 0xe3, 0xf3, 0xee, 0x70, + 0xa7, 0x0d, 0xb7, 0x6d, 0x1d, 0xc7, 0x2f, 0xdb, 0x79, 0xd3, 0x8b, 0x47, 0x09, + 0x11, + ], + [ + 0x12, 0x9b, 0xea, 0x42, 0x3d, 0xaf, 0xbb, 0x70, 0x7a, 0x9f, 0xee, 0xfb, 0xb2, + 0xb6, 0xeb, 0xab, 0xc7, 0xc0, 0xeb, 0xbf, + ], + [ + 0x5a, 0x2e, 0xaa, 0x59, 0x90, 0x6f, 0xa2, 0xb2, 0xa8, 0xff, 0x5d, 0xef, 0x8f, + 0x6f, 0xcd, 0x0e, 0xec, 0x9a, 0xd8, 0x2c, 0xf4, 0xb9, 0x1d, 0x1a, 0xea, 0xb7, + 0x31, 0x70, 0xf3, 0x12, 0xb7, 0x98, + ], + [ + 0xc3, 0x5c, 0xbb, 0xe6, 0x8c, 0x6d, 0x60, 0x9d, 0x1c, 0x21, 0x59, 0x84, 0x48, + 0x2f, 0x27, 0x07, 0x59, 0x4e, 0xeb, 0x25, 0x95, 0x66, 0xfe, 0xa8, 0x9c, 0x22, + 0x6e, 0xb7, 0x32, 0x60, 0xb8, 0xdc, 0xc5, 0x9e, 0xd9, 0x90, 0x7a, 0xb1, 0xb8, + 0xcf, 0xf6, 0xf8, 0xca, 0x53, 0x2d, 0xce, 0xf2, 0x65, + ], + [ + 0x46, 0xd2, 0xac, 0x35, 0xb6, 0x69, 0x81, 0x32, 0x9c, 0x95, 0x20, 0xc0, 0x3f, + 0x35, 0x2d, 0x5b, 0x89, 0x38, 0x5e, 0x13, 0xec, 0xb5, 0x4b, 0xd6, 0xea, 0xca, + 0x7b, 0xf8, 0xfe, 0x16, 0x27, 0x25, 0xda, 0xc6, 0xc4, 0x39, 0xa7, 0x68, 0x9c, + 0x56, 0xef, 0xaa, 0x23, 0xbe, 0xbd, 0x7f, 0xf9, 0x0b, 0x25, 0xbc, 0x47, 0xaa, + 0x4d, 0x23, 0x7c, 0x8b, 0x59, 0xbb, 0x9f, 0xfe, 0xfa, 0xc6, 0x90, 0x51, + ] + ), + test_case!( + [ + 0xa6, 0xb8, 0xb6, 0x36, 0xb6, 0xc7, 0xf1, 0x2c, 0xcb, 0xc2, 0xba, 0x8c, 0x8c, + 0x43, 0xa3, 0x25, 0x18, 0xfa, 0xe1, 0xe7, 0x3e, 0x35, 0x30, 0x62, 0x5c, 0x01, + 0x96, 0x32, 0x8c, 0x6c, 0x54, 0xa7, 0xa5, 0xea, 0x61, 0x26, 0x68, 0x8b, 0xbf, + 0x4e, 0x62, 0xfc, 0x5c, 0xdd, 0x10, 0x36, 0x09, 0x8c, 0xde, 0x34, 0xf7, 0x55, + 0x84, 0x05, 0xc0, 0x7a, 0x54, 0x95, 0x31, 0x00, 0x71, 0x8b, 0x14, 0xa6, 0x1f, + 0x03, 0x97, 0xd0, 0x4b, 0xed, 0x4e, 0x12, 0x98, 0x01, 0x74, 0xe2, 0x85, 0x11, + 0x5a, 0x5f, 0xc6, 0xaf, 0xc2, 0xe0, 0x30, 0xdc, 0x6e, 0xb4, 0xf5, 0xc7, 0xc5, + 0x7c, 0x07, 0x29, 0x74, 0x11, 0xe9, 0xe8, 0x28, 0xb3, 0xde, 0x70, 0xe1, 0xba, + 0xaa, 0xad, + ], + [ + 0xd9, 0x29, 0xd9, 0x92, 0xb9, 0xcd, 0x4b, 0x25, 0x89, 0xc2, 0x47, 0x58, 0xa2, + 0xfc, 0xa7, 0x77, 0xf7, 0x80, 0xa0, 0x48, + ], + [ + 0x27, 0xff, 0x4a, 0xd2, 0xb4, 0x35, 0xcc, 0x2f, 0xe1, 0xf6, 0xcb, 0x1d, 0x6c, + 0xcc, 0xf6, 0xd2, 0xa3, 0xda, 0x77, 0x15, 0x23, 0x41, 0x0d, 0x1d, 0xf2, 0xe3, + 0xc5, 0x19, 0x46, 0xbd, 0xac, 0xa7, + ], + [ + 0x25, 0x95, 0x1c, 0x36, 0x45, 0xc2, 0x45, 0xae, 0x0a, 0xec, 0xe0, 0xc3, 0xd1, + 0x39, 0xfd, 0xc9, 0xdd, 0x47, 0x49, 0x94, 0xbd, 0x26, 0x47, 0x2c, 0xf4, 0xcc, + 0x37, 0x6c, 0x60, 0xfe, 0x3f, 0xa2, 0x27, 0x1f, 0xfa, 0x18, 0xd2, 0xe5, 0x4b, + 0xfb, 0x97, 0xb6, 0x6f, 0xb1, 0x63, 0x4b, 0x99, 0x4a, + ], + [ + 0x19, 0xb5, 0x16, 0x3d, 0x81, 0x16, 0x0c, 0x67, 0xe6, 0xdc, 0xc4, 0x38, 0x7a, + 0xa7, 0xe4, 0x85, 0xfc, 0xab, 0xc3, 0x70, 0x3d, 0x52, 0x4d, 0xf5, 0x74, 0x96, + 0xd5, 0x61, 0x17, 0xff, 0xeb, 0x73, 0x4c, 0xdc, 0x62, 0xd5, 0xf8, 0x55, 0x32, + 0x2f, 0x84, 0x10, 0x46, 0xe9, 0x4b, 0x3f, 0xce, 0x10, 0x3d, 0xe8, 0x35, 0x2c, + 0xf8, 0x6f, 0x6f, 0x6e, 0x5b, 0x3f, 0x00, 0xd3, 0x82, 0x9c, 0x21, 0x13, + ] + ), + test_case!( + [ + 0x0a, 0x63, 0xf9, 0x5b, 0x0a, 0xe5, 0xc1, 0x2c, 0x5e, 0xe8, 0x7f, 0x5d, 0xfd, + 0x89, 0xe0, 0x9f, 0x75, 0x39, 0xe7, 0x0f, 0x1a, 0x40, 0x79, 0x66, 0x74, 0xf6, + 0x13, 0x8c, 0xf8, 0x6b, 0xd3, 0x9f, 0x57, 0xf4, 0x34, 0x77, 0xf1, 0x41, 0xac, + 0x5a, 0x1b, 0xeb, 0xf8, 0x35, 0x6f, 0x68, 0xf4, 0x3b, 0x9a, 0x0a, 0x53, 0xc3, + 0x2e, 0x2c, 0xba, 0x87, 0x4b, 0xc4, 0x6c, 0xba, 0xe1, 0xef, 0x84, 0x0a, 0x76, + 0x94, 0x81, 0x86, 0xd8, 0x78, 0x47, 0x5b, 0x7f, 0x35, 0xf9, 0x9e, 0xda, 0x02, + 0x10, 0xee, 0xc5, 0x4a, 0x96, 0x64, 0x7d, 0x70, 0x0e, 0x50, 0x2b, 0x21, 0xac, + 0x98, 0x20, 0x7f, 0xe2, 0xfc, 0x16, 0x4d, 0x89, 0xdb, 0x48, 0xb8, 0xd0, 0x78, + 0x63, 0x2d, 0xfd, + ], + [ + 0xb7, 0xb1, 0xa8, 0x42, 0xf0, 0xea, 0x83, 0x15, 0xd3, 0x02, 0x88, 0x31, 0x57, + 0x87, 0x8c, 0x74, 0x00, 0xd0, 0x24, 0x2c, + ], + [ + 0x53, 0x44, 0x81, 0x42, 0xcf, 0xe1, 0x18, 0x53, 0xa6, 0x73, 0xef, 0x5e, 0x4d, + 0xa1, 0x5c, 0xd3, 0x2d, 0x77, 0xdd, 0xea, 0x58, 0x80, 0xc4, 0xeb, 0x39, 0xff, + 0x7c, 0xc1, 0xc7, 0x53, 0x74, 0x78, + ], + [ + 0xe6, 0x8b, 0xef, 0x2c, 0xef, 0xcd, 0xf6, 0x99, 0xcb, 0xdd, 0xac, 0xf4, 0xa5, + 0x94, 0xa0, 0xe6, 0xdb, 0xe8, 0x60, 0x7c, 0xc1, 0x7b, 0xfb, 0xa1, 0xd8, 0x0b, + 0x07, 0x63, 0x6c, 0xbb, 0x99, 0xae, 0x01, 0xc0, 0xbf, 0x51, 0xe4, 0x7c, 0x18, + 0x5a, 0xd6, 0xc0, 0xd4, 0xa7, 0xa4, 0x11, 0x15, 0xe8, + ], + [ + 0xcb, 0x2e, 0xd1, 0x2d, 0xe8, 0x43, 0x9d, 0xf7, 0x0f, 0xfa, 0x12, 0x76, 0x54, + 0xb9, 0xd4, 0xd6, 0x20, 0xa0, 0xc8, 0xdd, 0xd7, 0xcc, 0xbe, 0xae, 0x39, 0xa8, + 0xdb, 0xe2, 0x55, 0xc9, 0xe4, 0x83, 0xf7, 0x90, 0xdb, 0x04, 0x38, 0x15, 0x40, + 0x76, 0x24, 0x2b, 0xea, 0xa7, 0x7c, 0xb4, 0xb6, 0x6c, 0x34, 0xde, 0xef, 0xcc, + 0x22, 0x73, 0xec, 0x0f, 0xf8, 0x8a, 0x92, 0xa9, 0x1a, 0x3a, 0xa9, 0x0e, + ] + ), + test_case!( + [ + 0x04, 0x0e, 0x7b, 0x1d, 0x79, 0xca, 0x81, 0x53, 0x70, 0xe0, 0x94, 0xbd, 0x16, + 0x75, 0xc1, 0xa2, 0x44, 0x14, 0x2a, 0xb8, 0x6b, 0x50, 0x46, 0x66, 0x5e, 0xc1, + 0x92, 0x27, 0xd1, 0x6d, 0xc3, 0x8a, 0x70, 0x25, 0x60, 0x42, 0xd2, 0xd9, 0x5c, + 0xc1, 0x8a, 0x3d, 0x22, 0xad, 0x55, 0xfe, 0xe6, 0xa8, 0xe6, 0x31, 0x66, 0x9c, + 0x68, 0x9f, 0x0b, 0x53, 0xf0, 0x7e, 0x46, 0xe6, 0x20, 0x5b, 0x0f, 0x1e, 0xe4, + 0x26, 0xd8, 0x23, 0x33, 0x65, 0x42, 0x3d, 0xd3, 0x5a, 0x6e, 0x66, 0x51, 0x72, + 0x9b, 0x4f, 0xa8, 0xd8, 0x26, 0xd6, 0xf6, 0x72, 0xfa, 0x88, 0x3e, 0x11, 0xff, + 0xe8, 0x16, 0x20, 0xc1, 0xc0, 0xeb, 0x3e, 0x2c, 0xec, 0x9c, 0xfd, 0x93, 0xc4, + 0x5a, 0xde, 0xbb, 0x44, + ], + [ + 0x51, 0x2f, 0x56, 0x57, 0x2c, 0xb8, 0xbf, 0x49, 0xc5, 0xb3, 0xc5, 0x52, 0xee, + 0x44, 0xed, 0xa9, 0x1d, 0x3f, 0x83, 0x38, + ], + [ + 0x2f, 0xf8, 0xbc, 0x67, 0x76, 0x95, 0x0a, 0x39, 0x31, 0x56, 0xf6, 0xa9, 0x82, + 0x40, 0x7f, 0xe4, 0xed, 0xad, 0x50, 0x22, 0x60, 0x5c, 0xf8, 0xf1, 0x84, 0x0f, + 0xe6, 0x36, 0x7b, 0xa3, 0x06, 0xf6, + ], + [ + 0x55, 0x4c, 0xa6, 0x3f, 0xea, 0x2b, 0xea, 0xb8, 0x4c, 0x66, 0x77, 0xce, 0x14, + 0x50, 0x63, 0x26, 0x9b, 0xa6, 0xee, 0x54, 0xad, 0x0f, 0x40, 0xd2, 0xd3, 0x56, + 0xe3, 0x66, 0x76, 0x85, 0x09, 0xce, 0xb6, 0xdd, 0xe8, 0x21, 0xfa, 0x09, 0xf9, + 0x83, 0xfb, 0x30, 0x75, 0x2e, 0x6c, 0x0f, 0x8b, 0xfa, + ], + [ + 0x1b, 0xa1, 0xf7, 0x8b, 0x03, 0x01, 0x5c, 0xa7, 0x5c, 0x51, 0x96, 0x38, 0x04, + 0x05, 0x72, 0xa2, 0x29, 0xe8, 0x03, 0x1f, 0x1e, 0x92, 0x0a, 0x96, 0x86, 0xd1, + 0xa5, 0xe5, 0xbd, 0xaf, 0xb1, 0x61, 0xa0, 0xe0, 0x8d, 0x3a, 0x6e, 0xeb, 0x05, + 0x03, 0xba, 0x63, 0xee, 0xce, 0x29, 0xaa, 0x99, 0x43, 0x9f, 0xab, 0xc7, 0xb9, + 0x40, 0xde, 0xe5, 0xf9, 0xc0, 0xe6, 0xaa, 0xbd, 0xac, 0x80, 0x8e, 0x87, + ] + ), + test_case!( + [ + 0x08, 0x91, 0x09, 0xbb, 0x22, 0xab, 0x09, 0xc5, 0x09, 0x09, 0xef, 0xe9, 0xcd, + 0xf5, 0xa2, 0x61, 0x7d, 0x86, 0x6a, 0x8c, 0x4e, 0xb3, 0x18, 0x40, 0x2a, 0xc8, + 0xbf, 0xe2, 0x1a, 0xfa, 0x89, 0x41, 0x5b, 0x2d, 0xe4, 0x59, 0xf0, 0xa3, 0x91, + 0xb3, 0x14, 0x6d, 0x2d, 0x0c, 0xc4, 0x96, 0x52, 0xad, 0x14, 0x16, 0x8e, 0x9f, + 0xce, 0x20, 0xb4, 0xfa, 0xf5, 0x51, 0xf3, 0x44, 0xbd, 0xaf, 0xf7, 0xbf, 0x28, + 0xfa, 0x4a, 0xb8, 0x2c, 0xf3, 0x20, 0x56, 0x02, 0x4a, 0xd1, 0x2a, 0x10, 0xcf, + 0x9a, 0x2a, 0x70, 0xcf, 0xeb, 0x29, 0xdf, 0x47, 0x8e, 0x39, 0xaf, 0xe7, 0xb2, + 0x93, 0xc3, 0x16, 0x26, 0x4a, 0x26, 0xc2, 0xbc, 0xa7, 0x52, 0x4f, 0xc8, 0x53, + 0x76, 0x57, 0x3c, 0x07, 0x05, + ], + [ + 0x71, 0x01, 0x3a, 0x3b, 0xe6, 0xfa, 0x3d, 0xcb, 0x65, 0x69, 0xd3, 0x65, 0x77, + 0x58, 0xfe, 0x8a, 0xdb, 0x71, 0x63, 0x12, + ], + [ + 0x4e, 0x4d, 0x99, 0x18, 0xd4, 0x2a, 0x42, 0x60, 0x0b, 0xa6, 0xfe, 0x3b, 0xd6, + 0x9c, 0xaf, 0x5b, 0x34, 0xd6, 0xad, 0xd0, 0xc9, 0x98, 0x92, 0xa1, 0x0e, 0x34, + 0x76, 0xc4, 0x04, 0xd1, 0x9d, 0x1d, + ], + [ + 0x36, 0xdf, 0x59, 0xb9, 0x54, 0x5e, 0xa2, 0x38, 0x34, 0x0f, 0x51, 0xf6, 0x9b, + 0x55, 0x39, 0xf1, 0x22, 0xa9, 0x69, 0x6c, 0x0d, 0x6e, 0xec, 0x18, 0xd3, 0x18, + 0x45, 0xe5, 0xd8, 0xcd, 0xeb, 0x50, 0xc9, 0x5d, 0xb7, 0xad, 0x75, 0xcf, 0xc5, + 0x5e, 0x48, 0x16, 0x7f, 0xbb, 0x11, 0xda, 0x78, 0x28, + ], + [ + 0x8d, 0x05, 0x41, 0xe9, 0x7d, 0xac, 0x4f, 0x6c, 0x4c, 0x5e, 0xe3, 0x0f, 0xe5, + 0x63, 0xd4, 0x74, 0x4b, 0x44, 0xc7, 0x83, 0xb4, 0xb1, 0xea, 0xa2, 0xf8, 0x03, + 0xe3, 0x1d, 0x13, 0xca, 0x3d, 0xeb, 0xb1, 0x5a, 0x15, 0x4c, 0x41, 0x95, 0xdc, + 0xb1, 0xc7, 0x48, 0x46, 0xa5, 0x45, 0x65, 0x83, 0x56, 0x8c, 0x79, 0x31, 0x53, + 0x07, 0x36, 0xc5, 0xfc, 0xcc, 0x74, 0xb5, 0x57, 0xbb, 0xbe, 0x8d, 0x01, + ] + ), + test_case!( + [ + 0x16, 0xed, 0xc2, 0xbb, 0xa9, 0xbd, 0x5c, 0x29, 0x77, 0xa5, 0x66, 0x2c, 0x85, + 0xb5, 0xa3, 0x36, 0x5b, 0x4a, 0x3a, 0xfd, 0x23, 0xbb, 0x79, 0x1c, 0x59, 0x21, + 0x8e, 0x00, 0xba, 0x04, 0xee, 0x43, 0x43, 0x85, 0x0a, 0x22, 0x9f, 0xc5, 0x40, + 0xd9, 0xc3, 0x9c, 0x91, 0x4d, 0xc1, 0xdd, 0x1a, 0x92, 0x2f, 0x30, 0xc3, 0x37, + 0x64, 0xfe, 0xe7, 0xa4, 0x42, 0x26, 0x7b, 0xa6, 0x2c, 0x80, 0x6b, 0x4d, 0x6a, + 0xa0, 0x90, 0xa1, 0xb2, 0x59, 0xac, 0x59, 0x1e, 0xea, 0x83, 0x22, 0x99, 0x4d, + 0x07, 0x70, 0x08, 0x0e, 0xc4, 0x3d, 0x95, 0x26, 0x27, 0x43, 0xca, 0x6b, 0x39, + 0x5e, 0x94, 0xf7, 0xdc, 0x43, 0x03, 0x9b, 0x90, 0xee, 0xe5, 0xbd, 0xcb, 0x7c, + 0x26, 0x81, 0xb9, 0x5b, 0xd6, 0xcc, + ], + [ + 0xd8, 0x06, 0xa6, 0xc6, 0x79, 0xf6, 0x6a, 0x53, 0x03, 0xe6, 0xf3, 0x70, 0x07, + 0xa7, 0x6a, 0x0a, 0x8f, 0x0c, 0x99, 0x5a, + ], + [ + 0xea, 0xc2, 0xf6, 0xd0, 0x0d, 0xdd, 0xac, 0x2c, 0x99, 0x60, 0x4b, 0x7d, 0x54, + 0x57, 0xff, 0x9f, 0x71, 0x2b, 0xd3, 0x3b, 0x15, 0x8e, 0x93, 0x67, 0x1b, 0x18, + 0xc9, 0x9c, 0xac, 0x01, 0x8b, 0x4d, + ], + [ + 0xe0, 0x9d, 0xe5, 0x6d, 0xe3, 0xf5, 0xc5, 0x84, 0x05, 0x51, 0x72, 0x44, 0xe5, + 0xdc, 0x2d, 0xb7, 0xe8, 0x66, 0x75, 0x72, 0x49, 0x5d, 0xff, 0xa9, 0x66, 0x7b, + 0x61, 0x8b, 0x0d, 0xeb, 0x00, 0x5a, 0x4d, 0x0c, 0xb0, 0xef, 0x8f, 0x8b, 0x78, + 0x9e, 0x80, 0xe6, 0x07, 0xd3, 0x65, 0xfc, 0x90, 0x94, + ], + [ + 0xd8, 0xa4, 0x2b, 0x57, 0x4f, 0x63, 0xe0, 0xf8, 0x5e, 0xd8, 0x54, 0xca, 0x7d, + 0x46, 0x4b, 0x3e, 0xbe, 0xbb, 0x22, 0x63, 0x8d, 0xe8, 0xfb, 0x17, 0xea, 0xbd, + 0xfa, 0x3f, 0x9f, 0x15, 0x84, 0x3d, 0x0b, 0xc3, 0x19, 0xc8, 0xbb, 0xbc, 0x7d, + 0xb4, 0x9e, 0xe1, 0xa0, 0x7a, 0x62, 0x97, 0xa2, 0xb7, 0x8a, 0x5f, 0x07, 0x6a, + 0x59, 0x28, 0xd3, 0xea, 0x23, 0xe7, 0xe9, 0x28, 0xcf, 0xbb, 0x4b, 0x70, + ] + ), + test_case!( + [ + 0xfc, 0xb6, 0x69, 0x62, 0xf1, 0x2c, 0xf4, 0x1e, 0x13, 0x73, 0x36, 0x76, 0x2a, + 0xed, 0xab, 0xd3, 0x1c, 0xaa, 0xed, 0x66, 0xa2, 0x04, 0x38, 0x24, 0x44, 0xab, + 0xc5, 0x3e, 0x34, 0xbe, 0x9f, 0x52, 0x7b, 0x7a, 0x41, 0x4d, 0xf0, 0x8f, 0xfc, + 0x8b, 0x39, 0xb9, 0x5e, 0x2a, 0x2c, 0xb7, 0x10, 0x68, 0xb9, 0xdb, 0x51, 0x72, + 0x77, 0x75, 0x40, 0x19, 0xcd, 0x01, 0x4b, 0xc1, 0x2d, 0x3b, 0xff, 0x84, 0x29, + 0x39, 0x72, 0x0a, 0x95, 0x33, 0xc5, 0xd9, 0xef, 0xa1, 0xd0, 0x00, 0xb4, 0x97, + 0xb9, 0xf2, 0x02, 0xeb, 0xa9, 0xdd, 0x1c, 0xb5, 0x1e, 0xef, 0xdd, 0x9d, 0x4e, + 0xed, 0x4d, 0x50, 0xb9, 0x34, 0xb5, 0x5f, 0xdf, 0x92, 0x27, 0x62, 0xc1, 0xb7, + 0xeb, 0x1a, 0xa6, 0xa2, 0x7e, 0x0b, 0x35, + ], + [ + 0x31, 0x43, 0x5c, 0xca, 0x06, 0xb6, 0xc9, 0xef, 0x74, 0x42, 0x62, 0xf6, 0x0a, + 0x20, 0x1b, 0x0e, 0x10, 0xf4, 0xdb, 0x53, + ], + [ + 0x56, 0x74, 0xf5, 0x95, 0x39, 0x41, 0x97, 0x58, 0x7a, 0x8f, 0x0f, 0x1e, 0x62, + 0x6c, 0xff, 0x2e, 0x96, 0xac, 0xfa, 0x0f, 0x3a, 0x82, 0x31, 0xfc, 0x24, 0x91, + 0xde, 0x47, 0x2e, 0x1d, 0x40, 0xeb, + ], + [ + 0x31, 0x1b, 0x64, 0x77, 0x0c, 0x4a, 0xff, 0xeb, 0x21, 0x4d, 0x86, 0xbe, 0xbb, + 0x87, 0x70, 0x16, 0xd8, 0x6d, 0x41, 0x34, 0xff, 0x45, 0xd5, 0x96, 0xfe, 0x7f, + 0xba, 0x49, 0x51, 0x14, 0x16, 0x17, 0x9a, 0x19, 0x7e, 0x25, 0xb6, 0xb9, 0x30, + 0x61, 0xa9, 0x5f, 0xa3, 0xe5, 0x48, 0x7a, 0x0f, 0x0e, + ], + [ + 0x53, 0xb3, 0x47, 0x7b, 0x80, 0x9a, 0x05, 0x9f, 0xa1, 0x19, 0xe8, 0x32, 0x07, + 0x7e, 0xbf, 0x78, 0x6c, 0xbd, 0x04, 0xc2, 0x96, 0x61, 0x66, 0x7a, 0x18, 0xc9, + 0x04, 0xd6, 0x77, 0x16, 0x22, 0xf6, 0xb3, 0xd9, 0x0e, 0x3e, 0x15, 0x41, 0x7d, + 0x57, 0x1a, 0xa3, 0x7b, 0x85, 0x05, 0xd0, 0x61, 0x99, 0xf9, 0x61, 0xc0, 0xa2, + 0x6f, 0xbc, 0x57, 0x67, 0xaf, 0xe5, 0x43, 0xed, 0xe8, 0x9e, 0xaa, 0xb6, + ] + ), + test_case!( + [ + 0xfa, 0x0f, 0xcc, 0xc3, 0xd7, 0x72, 0xd4, 0xba, 0xa5, 0x5c, 0x5b, 0xad, 0x4e, + 0xbc, 0x11, 0x04, 0xc6, 0x4c, 0x07, 0x52, 0x0f, 0x59, 0x9f, 0x76, 0x4a, 0xcb, + 0xa9, 0x69, 0x8a, 0xb6, 0x5e, 0x8e, 0x47, 0x40, 0x15, 0x99, 0xbe, 0xd2, 0x94, + 0x3b, 0xc4, 0x5f, 0x1b, 0xae, 0x38, 0x7b, 0x4e, 0x23, 0x0a, 0xcf, 0x6b, 0x7a, + 0xf3, 0xf9, 0x70, 0x2b, 0x73, 0xf6, 0xa1, 0xd3, 0xf8, 0x75, 0xba, 0xf0, 0x6e, + 0x08, 0xbc, 0x82, 0xf4, 0x4a, 0xb6, 0x83, 0xcb, 0x2f, 0x2f, 0xb9, 0x43, 0x2a, + 0x79, 0x3f, 0x54, 0x60, 0xd5, 0xd2, 0x1a, 0x8a, 0x31, 0x26, 0x4e, 0x90, 0x63, + 0x43, 0xd5, 0x9a, 0xdb, 0x0c, 0x10, 0x47, 0x08, 0x4f, 0x43, 0xff, 0x9c, 0x69, + 0x27, 0xd7, 0xf0, 0x0f, 0xea, 0x9d, 0xb1, 0x0d, + ], + [ + 0xbf, 0x92, 0x70, 0x6a, 0x3e, 0x60, 0x3c, 0x03, 0x43, 0xca, 0xff, 0x84, 0x90, + 0xc5, 0x30, 0xe8, 0xe3, 0x69, 0x18, 0x4a, + ], + [ + 0xfd, 0x1b, 0x42, 0x3b, 0xc8, 0x52, 0xe8, 0xe1, 0xc1, 0x0e, 0x8b, 0xff, 0xf5, + 0x1b, 0x41, 0xd1, 0x63, 0xcf, 0x87, 0x75, 0x0b, 0xd3, 0xa3, 0xba, 0xd1, 0x1b, + 0xd9, 0x82, 0xa3, 0xeb, 0x94, 0xab, + ], + [ + 0xbb, 0x0d, 0x99, 0x79, 0xe1, 0x4a, 0x94, 0x6d, 0x43, 0x0b, 0x9b, 0xe9, 0x86, + 0x0f, 0xc7, 0xbf, 0xc5, 0x55, 0x0c, 0xb0, 0x7f, 0x53, 0x44, 0xed, 0x73, 0x43, + 0x14, 0xc1, 0xf1, 0x27, 0xe5, 0xee, 0x7d, 0x47, 0xec, 0xd3, 0x17, 0xe7, 0x59, + 0xc5, 0xc2, 0xb4, 0x24, 0x89, 0x42, 0x44, 0x1a, 0x70, + ], + [ + 0x92, 0x6d, 0xe1, 0xfb, 0x19, 0xbd, 0x1f, 0x06, 0xda, 0xfd, 0x0e, 0x36, 0xc0, + 0x92, 0xa1, 0x9c, 0xb9, 0xf2, 0xa3, 0x24, 0x0a, 0xcc, 0xc4, 0x17, 0x50, 0x87, + 0xba, 0xa8, 0xcc, 0xaa, 0xef, 0x87, 0x7b, 0x32, 0xa6, 0x95, 0x36, 0x7d, 0x37, + 0xa8, 0xef, 0x66, 0xc4, 0x58, 0xb9, 0xd0, 0xaf, 0x4c, 0xa3, 0xf4, 0x9a, 0x1e, + 0xe0, 0x4f, 0xd5, 0x78, 0x90, 0xe1, 0xce, 0xe0, 0x45, 0x39, 0xb7, 0x57, + ] + ), + test_case!( + [ + 0xda, 0x26, 0x0b, 0x04, 0x34, 0x5e, 0x9a, 0xb4, 0xd3, 0x08, 0x01, 0xea, 0xd6, + 0x5f, 0xd2, 0x57, 0x49, 0xfc, 0x5b, 0x8e, 0xbc, 0x41, 0xab, 0x5c, 0x19, 0xc4, + 0x9f, 0xc5, 0x6c, 0x3d, 0xd1, 0xec, 0x97, 0xaf, 0xc6, 0x89, 0x88, 0xc4, 0xc4, + 0x5e, 0x5c, 0x6e, 0xb3, 0xa3, 0xed, 0x1f, 0xe1, 0x4b, 0x19, 0x76, 0xc3, 0x92, + 0xbc, 0x25, 0x15, 0x91, 0x8c, 0xb9, 0x59, 0x9a, 0x3b, 0xb3, 0x1b, 0xee, 0x22, + 0x8a, 0x0f, 0xe3, 0x55, 0x9a, 0xe7, 0xac, 0xbb, 0x00, 0x69, 0xb0, 0x04, 0xba, + 0xa0, 0xc8, 0xea, 0x64, 0x4f, 0x87, 0x9f, 0x74, 0x07, 0x89, 0xa0, 0x5f, 0x34, + 0xda, 0xec, 0x74, 0x59, 0x2a, 0x8f, 0xde, 0xcc, 0x91, 0x14, 0x77, 0x86, 0x6f, + 0x10, 0x77, 0xb6, 0x98, 0xc6, 0xaa, 0xcc, 0xd1, 0x73, + ], + [ + 0x02, 0x4a, 0xcc, 0x12, 0x4d, 0x8d, 0x62, 0x46, 0xa5, 0x3f, 0xae, 0x33, 0xb1, + 0x0c, 0x2f, 0x2c, 0x71, 0xa1, 0xc1, 0x56, + ], + [ + 0xe3, 0x87, 0xc8, 0xb5, 0x95, 0xa2, 0x53, 0x83, 0xf8, 0x24, 0xd7, 0xe2, 0x66, + 0x44, 0xee, 0x0e, 0x2a, 0x2f, 0x08, 0xd5, 0xfd, 0x0d, 0x98, 0x37, 0x49, 0x01, + 0x48, 0xb2, 0xd7, 0xcd, 0xed, 0xb7, + ], + [ + 0xd3, 0x75, 0x50, 0x6d, 0x13, 0x3a, 0x0b, 0xe2, 0x56, 0xc5, 0xea, 0xdd, 0xff, + 0x3f, 0x01, 0x94, 0xbf, 0x3f, 0x35, 0xd1, 0x10, 0x23, 0x7f, 0xce, 0x7b, 0x92, + 0xc8, 0x65, 0xd6, 0x17, 0x05, 0x20, 0x09, 0x75, 0x38, 0x6d, 0x3c, 0xbe, 0xf7, + 0x63, 0x46, 0xf5, 0x9d, 0xe0, 0x75, 0x0b, 0x74, 0x66, + ], + [ + 0x29, 0xf1, 0xff, 0x45, 0x06, 0x5d, 0x39, 0x05, 0x13, 0x49, 0x0e, 0xd9, 0xaf, + 0x45, 0x75, 0x94, 0xc0, 0x97, 0xb2, 0xd2, 0x26, 0x7c, 0xd1, 0x99, 0xdc, 0x72, + 0xfc, 0x85, 0xd5, 0x81, 0x13, 0x8e, 0x2b, 0xd2, 0xff, 0x61, 0xae, 0x6c, 0x31, + 0x73, 0xe2, 0x88, 0xe2, 0xea, 0xa3, 0xb8, 0x74, 0xfe, 0x24, 0x0f, 0x88, 0x07, + 0x63, 0x2c, 0x8c, 0xb3, 0x87, 0xc9, 0xda, 0x24, 0x95, 0x9a, 0x1b, 0xf0, + ] + ), + test_case!( + [ + 0xfa, 0x16, 0x60, 0x22, 0x9c, 0x82, 0x54, 0xa5, 0x3d, 0x55, 0x53, 0x30, 0xbf, + 0xfa, 0x34, 0x6a, 0xd0, 0xc8, 0xf3, 0xa7, 0xb6, 0xeb, 0x91, 0x28, 0x31, 0xbe, + 0x80, 0x35, 0x7c, 0x14, 0xa2, 0x1d, 0x49, 0x7c, 0xe2, 0x19, 0xbd, 0xd4, 0xef, + 0x10, 0xdc, 0xf1, 0xff, 0x73, 0x2f, 0xe8, 0x92, 0x55, 0xbf, 0xca, 0x74, 0x65, + 0xc4, 0xb5, 0xa1, 0x6b, 0x0e, 0xe1, 0xc9, 0x84, 0x02, 0xad, 0x7c, 0x5f, 0xd9, + 0xa7, 0x80, 0x2b, 0x86, 0x25, 0x15, 0xb1, 0xd9, 0xc2, 0xed, 0x2b, 0x03, 0xae, + 0x05, 0x36, 0x87, 0x1b, 0x2a, 0x5f, 0x89, 0x0c, 0x01, 0x1b, 0xc4, 0x69, 0x1a, + 0xb5, 0xd0, 0x46, 0x39, 0xed, 0x1c, 0xfd, 0x80, 0x3d, 0xbe, 0x66, 0xcc, 0x2b, + 0x40, 0xc5, 0x5e, 0x28, 0x1d, 0xc0, 0xc3, 0xec, 0x5d, 0x26, + ], + [ + 0x71, 0x22, 0x5e, 0x1d, 0x93, 0x49, 0x48, 0xd6, 0x81, 0xba, 0x85, 0xae, 0x53, + 0xf3, 0x02, 0xa5, 0xf7, 0x53, 0xf8, 0xe8, + ], + [ + 0xdc, 0xe2, 0x87, 0x83, 0x6f, 0x56, 0x6a, 0x4b, 0xc1, 0xd5, 0xdc, 0x28, 0xd8, + 0x5d, 0xdb, 0x51, 0xd3, 0x18, 0x5f, 0xb4, 0x6b, 0x79, 0x54, 0xe6, 0xad, 0xa4, + 0xcc, 0xae, 0xd7, 0x10, 0xf7, 0xfc, + ], + [ + 0x25, 0xb8, 0xf6, 0xec, 0xba, 0x39, 0x8c, 0xd2, 0xe6, 0x24, 0xb6, 0xc9, 0x1c, + 0x68, 0x4b, 0x17, 0xfe, 0xd3, 0x8e, 0x9e, 0x88, 0xc0, 0xbf, 0x03, 0x5b, 0xec, + 0x3d, 0x63, 0x80, 0xf5, 0xee, 0x9b, 0x40, 0x92, 0x14, 0x62, 0xd6, 0x28, 0x45, + 0x49, 0x70, 0x07, 0xff, 0x8b, 0x66, 0x99, 0x2d, 0xb8, + ], + [ + 0xf2, 0xf3, 0x77, 0xc3, 0x88, 0x05, 0xd3, 0x8d, 0x0f, 0x45, 0x10, 0x2c, 0xd8, + 0x3f, 0x53, 0xea, 0x4a, 0x2a, 0x3e, 0x2b, 0xf6, 0x33, 0xd9, 0x6e, 0x14, 0xe6, + 0xd3, 0x7d, 0x86, 0x8b, 0x88, 0xb4, 0x1a, 0x3e, 0xec, 0xa7, 0x91, 0x17, 0x78, + 0x0e, 0x70, 0xe8, 0x65, 0x5f, 0x66, 0x82, 0xee, 0x20, 0xdd, 0x0e, 0xb0, 0x17, + 0x43, 0x0c, 0x74, 0x9b, 0x72, 0x39, 0x9f, 0xca, 0x51, 0x23, 0xa0, 0x44, + ] + ), + test_case!( + [ + 0xe9, 0x14, 0xcd, 0x1d, 0xaa, 0xa3, 0xaa, 0xee, 0x42, 0x9e, 0xc3, 0x99, 0xf6, + 0x7f, 0x46, 0xa0, 0x69, 0x3c, 0x36, 0x3f, 0x86, 0xe4, 0xaa, 0xbb, 0xd1, 0x46, + 0x33, 0xf9, 0x8a, 0x6a, 0xb3, 0x63, 0xd1, 0x2b, 0xc6, 0xdd, 0x18, 0x46, 0x64, + 0xa9, 0x53, 0x53, 0xf7, 0x3c, 0xf7, 0x71, 0x79, 0x1d, 0x53, 0x58, 0x69, 0x5d, + 0x01, 0x49, 0xfc, 0x5f, 0x04, 0x84, 0xd4, 0xb5, 0xea, 0xcb, 0x84, 0xd2, 0x1f, + 0x55, 0x32, 0xf8, 0xfe, 0xed, 0xc9, 0xac, 0x0d, 0x78, 0x35, 0x5e, 0xca, 0x03, + 0x57, 0x25, 0x26, 0x5d, 0x7d, 0xfa, 0x39, 0x48, 0xed, 0xde, 0xc4, 0x97, 0x2b, + 0x78, 0xb4, 0x1e, 0x50, 0xee, 0x57, 0xc7, 0x4e, 0xc2, 0xcc, 0x9a, 0xe7, 0x8e, + 0x1b, 0x3d, 0x00, 0x46, 0x38, 0x27, 0xfb, 0x06, 0x27, 0x2f, 0xae, + ], + [ + 0xee, 0x1a, 0x6d, 0xe5, 0x66, 0xa8, 0x5a, 0xc6, 0x94, 0x6c, 0x87, 0xa7, 0x0d, + 0xab, 0x7d, 0x4a, 0xab, 0xfd, 0xde, 0xf9, + ], + [ + 0x41, 0xa3, 0x87, 0xff, 0x2e, 0x53, 0xd4, 0x03, 0xaf, 0x0b, 0x00, 0xe5, 0x6d, + 0x09, 0x5b, 0x84, 0xa4, 0x99, 0x05, 0x6a, 0xc3, 0x60, 0x2b, 0xea, 0x0d, 0x33, + 0x39, 0x2c, 0x15, 0x78, 0xd6, 0x15, + ], + [ + 0xe3, 0x86, 0x61, 0xaa, 0xf6, 0x1d, 0x8e, 0xd7, 0x95, 0x53, 0x30, 0x04, 0xcb, + 0xe0, 0x5e, 0x27, 0xb0, 0x26, 0x14, 0xeb, 0xa4, 0xfb, 0x25, 0xda, 0x1f, 0x25, + 0xb7, 0xab, 0x6e, 0x00, 0xcc, 0x8b, 0xb3, 0x7d, 0x31, 0xd8, 0xb8, 0x20, 0x7a, + 0x66, 0x7e, 0xb1, 0x0d, 0x49, 0x9c, 0x42, 0xfe, 0x6c, + ], + [ + 0x8a, 0xb0, 0x44, 0xe2, 0x02, 0xdb, 0x19, 0x9e, 0x3b, 0xe9, 0x54, 0xa1, 0x75, + 0x8d, 0xdc, 0xda, 0x9c, 0xa3, 0x79, 0x58, 0x1b, 0xfb, 0xa8, 0xbc, 0x8b, 0x71, + 0xad, 0x54, 0x7c, 0x48, 0xc6, 0x82, 0xfb, 0xf1, 0x7e, 0xb9, 0x10, 0xe7, 0x33, + 0x01, 0x2c, 0xa6, 0xf6, 0x59, 0x93, 0xe4, 0x20, 0x18, 0x27, 0xc3, 0xfb, 0x7e, + 0x10, 0xd8, 0x26, 0xab, 0x64, 0xe2, 0xa3, 0xc6, 0x83, 0x81, 0xb1, 0xe3, + ] + ), + test_case!( + [ + 0xcd, 0x38, 0x14, 0x08, 0xbb, 0x30, 0x55, 0xb1, 0x96, 0xb6, 0xe1, 0xd3, 0x3a, + 0xd6, 0x6c, 0xb0, 0x9f, 0x59, 0xe2, 0xef, 0xd8, 0x37, 0x65, 0x29, 0x57, 0x59, + 0xb3, 0xae, 0xbe, 0x51, 0x1c, 0xc9, 0xe2, 0x6e, 0x1f, 0x7d, 0x91, 0x88, 0xdf, + 0x71, 0xff, 0x1e, 0xd2, 0x0a, 0x83, 0xfe, 0xa4, 0xcd, 0xf6, 0xbb, 0x78, 0x62, + 0xaf, 0xd5, 0x4c, 0x4e, 0xa4, 0x7b, 0x9d, 0xaa, 0x71, 0x53, 0xba, 0xbe, 0x9f, + 0xb9, 0x3b, 0xe3, 0x7d, 0x0b, 0xe9, 0xa9, 0x6e, 0xbe, 0x3b, 0x75, 0xbf, 0x30, + 0x0f, 0x4c, 0x38, 0x59, 0xc2, 0x50, 0xcb, 0x0d, 0xc8, 0xb8, 0xf7, 0x68, 0xcb, + 0xe1, 0x7f, 0x72, 0x36, 0xa7, 0xa6, 0x8f, 0x99, 0x41, 0x7f, 0x09, 0x69, 0xc5, + 0x53, 0xf7, 0x97, 0x46, 0xf4, 0x28, 0x65, 0x82, 0x51, 0x1d, 0x77, 0x45, + ], + [ + 0xce, 0x77, 0xa7, 0x1c, 0xce, 0xbf, 0x34, 0x15, 0xeb, 0xfc, 0x13, 0x66, 0xad, + 0x27, 0xad, 0x6b, 0x25, 0x43, 0xc9, 0xfc, + ], + [ + 0x8d, 0xdc, 0x55, 0xbd, 0x0a, 0xc3, 0xf3, 0xe8, 0xf6, 0x45, 0x9a, 0x18, 0x16, + 0xf7, 0xcb, 0x5c, 0x92, 0x3b, 0x8d, 0xfa, 0x63, 0x12, 0xb0, 0xf3, 0x0f, 0x33, + 0x72, 0xe1, 0x0f, 0x20, 0x17, 0x2a, + ], + [ + 0x7d, 0x9a, 0x51, 0xf1, 0xac, 0xdb, 0x98, 0xc9, 0x7c, 0xe1, 0x2f, 0xa7, 0x62, + 0x9b, 0x11, 0x17, 0x4a, 0x8d, 0xdb, 0xd3, 0x25, 0xd1, 0x3c, 0x65, 0x59, 0x12, + 0x0e, 0x60, 0x7d, 0xe6, 0xed, 0x40, 0xeb, 0x19, 0x99, 0x1f, 0xfc, 0xac, 0x43, + 0xc5, 0x18, 0x1a, 0x23, 0x9d, 0x9d, 0x05, 0x77, 0xee, + ], + [ + 0x7b, 0xc8, 0xe7, 0x3f, 0xe4, 0xca, 0x5f, 0x74, 0x3a, 0x78, 0xed, 0xde, 0xc5, + 0xa7, 0x76, 0xdd, 0x48, 0x1b, 0x06, 0x3e, 0x1c, 0x95, 0x98, 0x6c, 0x7f, 0xb9, + 0x79, 0xba, 0x74, 0x43, 0xa2, 0xa3, 0x73, 0x22, 0x42, 0x94, 0xb4, 0xf3, 0xef, + 0xb5, 0xb9, 0x93, 0x81, 0x5b, 0xa3, 0x44, 0xa7, 0xf6, 0x3e, 0x73, 0xa5, 0x67, + 0x8e, 0xa8, 0xa0, 0x40, 0xe2, 0xef, 0xbf, 0x4a, 0x0d, 0x5e, 0x29, 0xdc, + ] + ), + test_case!( + [ + 0xb1, 0x65, 0x9d, 0xe2, 0xe3, 0x67, 0x82, 0xf3, 0x8a, 0x22, 0xc5, 0x80, 0x54, + 0x2c, 0xc9, 0xc9, 0xc9, 0xaf, 0x93, 0x18, 0xcd, 0xe8, 0x21, 0x1a, 0x49, 0xa7, + 0xbc, 0x07, 0x7c, 0xba, 0xa3, 0x5b, 0x44, 0x69, 0x93, 0xe7, 0x17, 0x41, 0xad, + 0xd6, 0x56, 0xc5, 0x96, 0xf9, 0x51, 0xc3, 0x7e, 0x3c, 0x52, 0xdc, 0xe2, 0x86, + 0x46, 0xa6, 0x8e, 0x14, 0x33, 0xf1, 0x46, 0xc1, 0x4f, 0xda, 0x7e, 0x32, 0x75, + 0xca, 0xb3, 0x54, 0x81, 0x74, 0x39, 0x42, 0x23, 0xef, 0x84, 0x0b, 0x27, 0x3f, + 0xf7, 0xf4, 0x34, 0x06, 0x91, 0x88, 0xcd, 0x00, 0x55, 0xdb, 0x22, 0xbe, 0xdb, + 0x97, 0xa5, 0x71, 0x99, 0x21, 0xaa, 0x14, 0x47, 0x99, 0xe4, 0x7c, 0xbc, 0x3a, + 0xb3, 0x70, 0xc0, 0x1d, 0x70, 0xbf, 0xfc, 0xc5, 0x37, 0xc4, 0xdd, 0x04, 0xcc, + ], + [ + 0x74, 0x61, 0x00, 0x22, 0x50, 0x99, 0x43, 0x5c, 0x77, 0xc2, 0x05, 0x19, 0xd1, + 0x8c, 0x87, 0x5e, 0x7d, 0x8d, 0x3d, 0xb5, + ], + [ + 0x1c, 0xd5, 0xa3, 0x90, 0x43, 0x39, 0x4f, 0x0a, 0x1d, 0xa4, 0x01, 0x79, 0xde, + 0x1b, 0x82, 0xfa, 0xbf, 0x2a, 0xcc, 0xa3, 0x47, 0x8e, 0xb3, 0x76, 0xfc, 0x5f, + 0x68, 0xdf, 0x07, 0x37, 0x32, 0xcd, + ], + [ + 0x5e, 0x73, 0x8c, 0x16, 0xf6, 0x0b, 0x6c, 0xa3, 0xc4, 0x50, 0xc3, 0x56, 0xba, + 0x1e, 0xc0, 0x38, 0xe0, 0xb6, 0x7d, 0x80, 0x10, 0x48, 0xca, 0xbe, 0x0e, 0x04, + 0x1c, 0xc0, 0x45, 0x3d, 0xfd, 0xc1, 0xaf, 0xda, 0x12, 0xc8, 0x92, 0x41, 0x69, + 0x20, 0x0d, 0xfb, 0x92, 0x86, 0x52, 0xca, 0x42, 0xb9, + ], + [ + 0xd1, 0x67, 0x13, 0x0d, 0x9c, 0x66, 0x7e, 0xda, 0xbd, 0xed, 0x15, 0xd2, 0x51, + 0x30, 0xc4, 0x1b, 0xea, 0xaf, 0x45, 0x99, 0x60, 0x6a, 0x5d, 0xbb, 0x3b, 0x1d, + 0xc2, 0x96, 0xbe, 0xaf, 0x03, 0x77, 0xc1, 0x4e, 0xb2, 0xb0, 0x6e, 0x76, 0xd6, + 0x38, 0xf2, 0x61, 0xa4, 0x53, 0x72, 0x3b, 0xe2, 0x94, 0x54, 0x11, 0x96, 0xe2, + 0x04, 0x7d, 0x82, 0x33, 0x2a, 0x83, 0xeb, 0xaf, 0x7a, 0x31, 0x93, 0xc6, + ] + ), + test_case!( + [ + 0x28, 0xf9, 0x3c, 0x84, 0x76, 0x04, 0x5a, 0x55, 0x3b, 0x78, 0x4d, 0x86, 0x34, + 0xc4, 0x8a, 0x11, 0xc9, 0x7b, 0xcf, 0x1a, 0x01, 0x02, 0xb5, 0x4b, 0x27, 0x92, + 0x5d, 0xa7, 0x72, 0xcc, 0xdc, 0x61, 0xd3, 0x09, 0xc8, 0x48, 0x80, 0x09, 0xd3, + 0x8b, 0x3f, 0xf5, 0x25, 0x86, 0x5e, 0x53, 0x88, 0xce, 0x8c, 0x1d, 0x4b, 0x89, + 0x92, 0x23, 0xed, 0x7d, 0x6c, 0x84, 0x68, 0xb0, 0x71, 0x59, 0x8e, 0xd8, 0x4d, + 0x11, 0xad, 0x2a, 0xe4, 0x5b, 0x96, 0x26, 0xf5, 0xbc, 0x07, 0x3c, 0xde, 0x43, + 0x56, 0x5a, 0x70, 0x54, 0x27, 0x66, 0x32, 0xf7, 0x3a, 0x92, 0x71, 0x57, 0xc0, + 0xfe, 0xf1, 0x8b, 0x2b, 0x83, 0x13, 0x5e, 0xf6, 0xcc, 0x8d, 0x5d, 0xb4, 0xbf, + 0xfc, 0x9a, 0xf3, 0xa2, 0x7d, 0xb1, 0xe6, 0x29, 0x93, 0x96, 0xde, 0xf5, 0x2f, + 0xb6, + ], + [ + 0xc6, 0xf4, 0x05, 0xed, 0x7e, 0x74, 0xc4, 0x64, 0xbb, 0x94, 0x69, 0x3f, 0x76, + 0xb5, 0x5e, 0x06, 0x9b, 0x8a, 0x29, 0xb8, + ], + [ + 0x3d, 0x06, 0x17, 0x59, 0x7b, 0xc0, 0x6f, 0x36, 0x1e, 0x4a, 0xad, 0x93, 0x45, + 0xcb, 0x2c, 0x42, 0xd8, 0xfb, 0x68, 0x5e, 0x50, 0xb3, 0x1f, 0x7d, 0xd3, 0x4f, + 0xf8, 0x10, 0x6b, 0x64, 0xf7, 0x08, + ], + [ + 0xa2, 0x23, 0x4f, 0x6c, 0xee, 0xd3, 0xbe, 0x45, 0x56, 0x5c, 0x8c, 0x9e, 0x8e, + 0x66, 0x23, 0xca, 0x60, 0x7b, 0xa4, 0xc9, 0xb1, 0x96, 0x82, 0x45, 0x68, 0x87, + 0x9c, 0x8e, 0x44, 0x65, 0xa0, 0x35, 0x8e, 0xcf, 0x98, 0x3a, 0x21, 0xdd, 0xb4, + 0x20, 0x93, 0xc5, 0x80, 0xc3, 0x7c, 0xaa, 0x56, 0x26, + ], + [ + 0xc1, 0x68, 0xe6, 0x44, 0x84, 0xcf, 0x77, 0xee, 0xea, 0xa2, 0xbb, 0xdb, 0xcb, + 0xa7, 0xed, 0xdf, 0xfe, 0x57, 0x3f, 0x23, 0x40, 0x4c, 0x0c, 0x2a, 0x27, 0x7e, + 0x64, 0x5e, 0x06, 0xe0, 0xb7, 0xd2, 0xba, 0x1a, 0xbd, 0xa3, 0x82, 0xb9, 0xc5, + 0xc7, 0x36, 0x43, 0xbc, 0x67, 0xa5, 0xfc, 0x33, 0x80, 0xba, 0x7b, 0x06, 0x7e, + 0x8c, 0xa5, 0xa6, 0x5c, 0xe3, 0x72, 0x0b, 0x41, 0xe5, 0x9d, 0xc8, 0xef, + ] + ), + test_case!( + [ + 0x3b, 0xd5, 0x8d, 0x03, 0x6b, 0x3f, 0x48, 0x08, 0x9c, 0x94, 0xa3, 0x41, 0xbb, + 0x74, 0x0e, 0xc5, 0x9b, 0xc1, 0x02, 0x53, 0xb2, 0xcd, 0xbe, 0xee, 0x77, 0x7d, + 0x76, 0x59, 0xd7, 0x2f, 0x94, 0xb0, 0x91, 0x4f, 0x69, 0xeb, 0x68, 0xb4, 0xd4, + 0x34, 0x31, 0x70, 0xc9, 0x85, 0xf2, 0x7e, 0x7e, 0x82, 0x0d, 0x1b, 0x0f, 0xcf, + 0xaa, 0xf5, 0xce, 0xf8, 0x67, 0xae, 0x19, 0x5a, 0xc1, 0xcc, 0x8a, 0xbf, 0x93, + 0xa8, 0xf0, 0x58, 0x4a, 0x33, 0xe8, 0x91, 0x39, 0xe2, 0xf3, 0x1a, 0x78, 0xae, + 0xb8, 0x0a, 0xb1, 0x14, 0x90, 0xe8, 0xe7, 0xf4, 0x97, 0x15, 0x50, 0x84, 0x73, + 0x08, 0xd9, 0x79, 0x76, 0x69, 0x90, 0x9c, 0xe2, 0x62, 0xa6, 0x3b, 0x12, 0x8b, + 0x78, 0xb3, 0x1c, 0xa4, 0x5b, 0x3c, 0xe9, 0x29, 0xda, 0xaf, 0xcd, 0x85, 0x0d, + 0xd6, 0x20, + ], + [ + 0x21, 0xc1, 0xe1, 0x5d, 0x4b, 0x96, 0x24, 0xd7, 0xa8, 0xb4, 0x90, 0x78, 0x97, + 0xe2, 0xcf, 0xd1, 0xc8, 0xba, 0x2a, 0x84, + ], + [ + 0x5d, 0xa5, 0xd6, 0x23, 0x84, 0x42, 0x07, 0x6b, 0x9f, 0xd7, 0x8f, 0x5b, 0xd3, + 0xd2, 0xf3, 0xc4, 0x7f, 0xee, 0x87, 0x14, 0xa4, 0xcb, 0x1c, 0x4d, 0xbe, 0xfd, + 0xfb, 0x8f, 0xfd, 0x51, 0x89, 0x73, + ], + [ + 0x85, 0x31, 0xc9, 0x87, 0x03, 0x7d, 0x56, 0xc7, 0x2d, 0x64, 0x2c, 0xb9, 0xb9, + 0xa2, 0x1a, 0x20, 0xa8, 0x52, 0xf8, 0x67, 0x0b, 0xad, 0x5f, 0x62, 0xa2, 0xec, + 0x6c, 0xa7, 0xc3, 0xdb, 0x01, 0xd1, 0xdd, 0xdb, 0x8f, 0xb2, 0x1b, 0x41, 0xf3, + 0xf8, 0xad, 0x19, 0xba, 0x0f, 0x09, 0xc6, 0x58, 0x2f, + ], + [ + 0x04, 0x43, 0x26, 0x1b, 0x38, 0x7e, 0x1f, 0x9c, 0x07, 0x4a, 0xf0, 0x98, 0xd2, + 0xcf, 0x2a, 0x60, 0x53, 0x5c, 0x62, 0x14, 0x7b, 0xb7, 0x3d, 0x35, 0x05, 0xbf, + 0x7d, 0xc0, 0xfc, 0x3f, 0xb0, 0xac, 0xb9, 0x6b, 0xe3, 0xa5, 0x6e, 0x8b, 0xff, + 0xa2, 0x6a, 0xa2, 0xcf, 0x80, 0x14, 0x09, 0x92, 0x31, 0x23, 0x3c, 0x5c, 0x9d, + 0xb5, 0x05, 0xfe, 0x52, 0xa8, 0x6b, 0x8d, 0x29, 0x4d, 0x7e, 0xcd, 0x55, + ] + ), + test_case!( + [ + 0xaf, 0x98, 0x3e, 0x36, 0x71, 0x5f, 0xe4, 0x10, 0xc6, 0x89, 0x6b, 0xdf, 0xb6, + 0xff, 0xe2, 0xc2, 0x64, 0xaf, 0xd7, 0xa3, 0x4a, 0x4e, 0x0d, 0x4e, 0x31, 0xf5, + 0xb5, 0xc2, 0x7d, 0x8b, 0x6c, 0xc8, 0xfb, 0xf7, 0x2f, 0xbb, 0xaa, 0x4d, 0x95, + 0x0f, 0x78, 0x8e, 0x92, 0x84, 0x0f, 0x30, 0x28, 0x7b, 0xdc, 0x77, 0x66, 0x93, + 0xbc, 0x9c, 0x66, 0x7b, 0x1e, 0x49, 0x42, 0xd8, 0x64, 0x8f, 0x2d, 0x14, 0x43, + 0xec, 0x37, 0x2a, 0x65, 0x80, 0x93, 0xbe, 0x70, 0xf4, 0x36, 0x2d, 0x8d, 0xbc, + 0x6a, 0x4b, 0xe0, 0x5a, 0x5b, 0x66, 0xe2, 0x93, 0xfe, 0xf8, 0xeb, 0x07, 0xfd, + 0x0d, 0x5f, 0x15, 0x03, 0xe1, 0x5d, 0x9e, 0xa8, 0x23, 0x60, 0xf5, 0x8b, 0xfc, + 0xbf, 0x7c, 0xef, 0xbc, 0xbb, 0x30, 0x63, 0x83, 0xdf, 0xec, 0x7f, 0x51, 0x0f, + 0xd4, 0xf8, 0x0a, + ], + [ + 0xdc, 0x75, 0xbf, 0xa6, 0xc2, 0x0c, 0xfe, 0x23, 0x29, 0xd5, 0x20, 0x80, 0x60, + 0x93, 0x62, 0x31, 0xbe, 0x8b, 0x61, 0x90, + ], + [ + 0x37, 0xc6, 0xb5, 0x09, 0x61, 0x29, 0xbb, 0xa4, 0x38, 0xba, 0xff, 0x13, 0xdb, + 0xe5, 0xdd, 0x5c, 0x08, 0x64, 0xcc, 0x73, 0x5d, 0xee, 0xdc, 0x2d, 0x72, 0xa4, + 0x49, 0x63, 0x77, 0x74, 0xbd, 0x05, + ], + [ + 0x76, 0xfe, 0x98, 0xcd, 0xec, 0x95, 0xb3, 0x2f, 0x11, 0x1c, 0x73, 0xa1, 0x9a, + 0x99, 0x62, 0xf3, 0x76, 0x4d, 0x56, 0xc1, 0xc1, 0xee, 0x9e, 0xc0, 0x23, 0xf1, + 0xbb, 0xac, 0x1b, 0xbb, 0x9c, 0x84, 0xc9, 0x6a, 0x81, 0xb7, 0xfc, 0xd4, 0x99, + 0xe4, 0xa2, 0xb8, 0xa8, 0x4f, 0x88, 0xc9, 0x9b, 0x90, + ], + [ + 0x79, 0x9b, 0x61, 0x00, 0x7f, 0x80, 0x9a, 0xa5, 0x75, 0x9f, 0x24, 0x8d, 0x65, + 0x72, 0x47, 0xa2, 0xb5, 0x8d, 0xb2, 0x4c, 0x65, 0x78, 0x12, 0xb6, 0x75, 0x94, + 0x29, 0xd1, 0x1f, 0x35, 0xfb, 0x01, 0x33, 0x0f, 0xca, 0x51, 0xb8, 0xc1, 0x86, + 0x83, 0xfe, 0xb9, 0xf7, 0x58, 0x41, 0x75, 0x54, 0x9e, 0x48, 0x2d, 0xe9, 0xbd, + 0xac, 0x2e, 0xce, 0xc7, 0x11, 0x2c, 0xbc, 0x06, 0xe8, 0xa9, 0x0e, 0xe9, + ] + ), + test_case!( + [ + 0x9c, 0x3f, 0x25, 0x14, 0x00, 0x78, 0xfa, 0x99, 0x6b, 0x73, 0xe3, 0x19, 0x49, + 0xb9, 0x17, 0x98, 0x75, 0xae, 0xb0, 0x06, 0xba, 0x1e, 0xdc, 0xdb, 0x44, 0x25, + 0x7d, 0xe9, 0x54, 0xdb, 0x19, 0x5a, 0xad, 0x39, 0xbd, 0x9e, 0x55, 0xc0, 0x64, + 0xe0, 0x9f, 0x1e, 0xf0, 0x68, 0xeb, 0x85, 0xf4, 0xdc, 0x45, 0x35, 0x62, 0x1e, + 0xb7, 0x46, 0x20, 0xa4, 0xdb, 0x0e, 0x80, 0xb8, 0x9a, 0xec, 0xa9, 0xa7, 0x10, + 0xa1, 0x1f, 0x3f, 0x6b, 0x94, 0xd4, 0x13, 0x63, 0x63, 0xd6, 0x9f, 0xdf, 0x51, + 0x7d, 0x69, 0x7a, 0xfa, 0x8a, 0x39, 0x16, 0xbc, 0xad, 0x3a, 0x60, 0x5f, 0xad, + 0x59, 0xa4, 0xb5, 0x98, 0x77, 0x71, 0xbc, 0xff, 0x89, 0xc6, 0x31, 0xf5, 0xd3, + 0x00, 0x56, 0x70, 0x3a, 0x4b, 0x3e, 0x66, 0xdf, 0x2c, 0xc5, 0x9b, 0xe5, 0xe3, + 0xa9, 0xe6, 0x44, 0x55, + ], + [ + 0xcb, 0x59, 0x0c, 0x31, 0x22, 0x0d, 0xd3, 0x0c, 0x6c, 0x4a, 0x82, 0x9d, 0xcd, + 0xec, 0xb0, 0xa8, 0xe4, 0xa2, 0xa1, 0xf6, + ], + [ + 0x8e, 0xfa, 0x25, 0xbd, 0x3d, 0x3a, 0xc8, 0x61, 0xb7, 0x3f, 0x6b, 0x64, 0xbc, + 0xea, 0x00, 0xe0, 0xda, 0xb8, 0xd0, 0xe7, 0x62, 0x89, 0xac, 0x1f, 0x0c, 0x35, + 0xac, 0xad, 0x5a, 0x46, 0x6e, 0x51, + ], + [ + 0x95, 0x87, 0x5b, 0xad, 0x5b, 0x7c, 0x01, 0x8e, 0x0e, 0x45, 0x40, 0xae, 0x08, + 0x93, 0xcd, 0xa4, 0xcb, 0xa9, 0x50, 0x92, 0xc6, 0xe7, 0x9d, 0xf2, 0xe4, 0x74, + 0xa0, 0xd4, 0x95, 0x11, 0x02, 0x81, 0x1a, 0xc2, 0x33, 0x95, 0xf4, 0x95, 0xac, + 0x35, 0xea, 0xd4, 0x7c, 0x37, 0x4f, 0xc9, 0x42, 0x5f, + ], + [ + 0x1e, 0xfe, 0x41, 0xfd, 0x93, 0xbf, 0x30, 0x32, 0xd3, 0x59, 0x4d, 0xad, 0xab, + 0xc6, 0xcd, 0x4a, 0x97, 0xf2, 0x8e, 0x21, 0x02, 0x83, 0x6a, 0x65, 0xc7, 0x34, + 0xf5, 0xcf, 0x38, 0xd2, 0xee, 0x16, 0x3c, 0x5f, 0xbc, 0x5a, 0xde, 0x09, 0x72, + 0x17, 0x02, 0x11, 0xa9, 0x63, 0x47, 0x09, 0xe0, 0xac, 0xcf, 0x35, 0x43, 0x14, + 0xae, 0x95, 0x4b, 0x0c, 0xb6, 0x06, 0x13, 0xb5, 0xf2, 0x5b, 0x5d, 0xfa, + ] + ), + test_case!( + [ + 0xb9, 0xb9, 0x77, 0x32, 0xba, 0x57, 0xa9, 0x2f, 0x6a, 0x3e, 0x17, 0xac, 0xa0, + 0xc6, 0xbd, 0x1a, 0x1d, 0x3f, 0x13, 0x29, 0xf7, 0x90, 0xce, 0x20, 0x2b, 0x27, + 0xca, 0x26, 0x96, 0x47, 0x1c, 0xbb, 0x72, 0x0b, 0x61, 0x04, 0xec, 0x61, 0xdb, + 0xe3, 0xde, 0xac, 0x52, 0xf7, 0x22, 0xde, 0xde, 0x6c, 0x6c, 0x44, 0x5f, 0x7d, + 0xf4, 0xcd, 0xf9, 0xff, 0xe0, 0x4f, 0x20, 0xd0, 0x86, 0x61, 0x0f, 0x12, 0x27, + 0x94, 0xbd, 0xad, 0xd3, 0xa0, 0xa0, 0xca, 0xdc, 0x96, 0x51, 0x8c, 0x05, 0xb6, + 0x6f, 0xbd, 0x58, 0xc3, 0x57, 0x12, 0x72, 0x59, 0x02, 0xda, 0x42, 0xf8, 0x72, + 0xa4, 0xbd, 0x17, 0x20, 0xd2, 0x0d, 0x2e, 0x7f, 0x94, 0xb5, 0x87, 0x3a, 0x49, + 0x3a, 0x7b, 0x8d, 0xd9, 0xee, 0x8d, 0x37, 0xb8, 0x52, 0x8a, 0xfe, 0x52, 0x9d, + 0xe8, 0xe4, 0xae, 0xce, 0x5d, + ], + [ + 0x0b, 0xb8, 0x37, 0xfc, 0xec, 0x5d, 0x07, 0x8f, 0x58, 0x45, 0xb4, 0x01, 0x12, + 0x74, 0x84, 0xf1, 0xe6, 0x95, 0x24, 0x1f, + ], + [ + 0x85, 0x02, 0x8b, 0x5a, 0x6a, 0x92, 0xe3, 0x88, 0x57, 0x20, 0x36, 0x78, 0x23, + 0x4b, 0x11, 0x21, 0x4d, 0x67, 0x9d, 0x9f, 0x8a, 0x34, 0xab, 0xad, 0x97, 0x45, + 0x6f, 0x14, 0x8f, 0x60, 0x67, 0x1a, + ], + [ + 0x47, 0x95, 0x35, 0x81, 0x04, 0xef, 0xdc, 0xb5, 0xc3, 0x0c, 0xe4, 0x35, 0x5d, + 0x36, 0xd5, 0xe7, 0x03, 0x78, 0x06, 0x06, 0x48, 0x8f, 0x7b, 0xd6, 0x87, 0xa7, + 0xcb, 0x8c, 0x4b, 0x34, 0x58, 0xcd, 0xcc, 0x69, 0xb5, 0x6b, 0x9b, 0xf9, 0xff, + 0xa9, 0x1a, 0x71, 0x84, 0x46, 0x67, 0x4e, 0xaf, 0xae, + ], + [ + 0x30, 0x83, 0x6e, 0x51, 0x41, 0x81, 0x6a, 0xc4, 0x82, 0x79, 0xcd, 0x74, 0x18, + 0x06, 0xc2, 0x8f, 0x8a, 0xc7, 0x9b, 0x4e, 0xdf, 0x0c, 0xda, 0x0b, 0xad, 0x4f, + 0xee, 0xe2, 0x56, 0x97, 0x03, 0x29, 0xde, 0x6d, 0xe7, 0x6b, 0xc6, 0x6c, 0x58, + 0x9e, 0xc8, 0x93, 0xb8, 0x47, 0x6e, 0x7d, 0x02, 0xd5, 0x54, 0x28, 0x6d, 0xe0, + 0x46, 0x78, 0xa7, 0x92, 0x54, 0x52, 0x7d, 0x56, 0xf7, 0xec, 0x21, 0x2a, + ] + ), + test_case!( + [ + 0x63, 0x78, 0x65, 0x8e, 0xb3, 0xac, 0xd1, 0xcc, 0x65, 0x2c, 0x9c, 0xdf, 0x37, + 0x94, 0xe2, 0x87, 0x22, 0x7e, 0x19, 0x12, 0x75, 0x92, 0xa6, 0x2f, 0xf1, 0x9c, + 0x64, 0x0d, 0x1f, 0xff, 0x53, 0x52, 0x52, 0xd2, 0x7c, 0x32, 0xff, 0x19, 0x5d, + 0xe6, 0x9a, 0x4f, 0x75, 0x2c, 0x67, 0x6d, 0x45, 0xb7, 0x4d, 0x19, 0x5a, 0xa1, + 0x31, 0x90, 0x99, 0xad, 0xd9, 0xac, 0x07, 0xe4, 0xe5, 0xec, 0xa5, 0x17, 0xcb, + 0xb6, 0x77, 0xac, 0x76, 0x9d, 0xf9, 0xb4, 0xae, 0xca, 0xd1, 0xf5, 0xb6, 0x87, + 0x86, 0x1a, 0x8b, 0xb3, 0x43, 0x78, 0x4d, 0x58, 0x43, 0x8a, 0xe4, 0xa0, 0xc0, + 0xb3, 0x18, 0xcb, 0x6d, 0x18, 0x9a, 0xbd, 0x52, 0xae, 0x55, 0x83, 0xf7, 0x3f, + 0x23, 0x79, 0xd5, 0xd9, 0x75, 0x71, 0x1d, 0x44, 0x0b, 0xf7, 0x3b, 0xd8, 0x48, + 0xb7, 0x14, 0xd8, 0xc8, 0x38, 0xf9, + ], + [ + 0x98, 0x10, 0x57, 0x64, 0xe2, 0x3e, 0x6b, 0xfa, 0x2a, 0x17, 0xa7, 0x62, 0x3f, + 0x87, 0xa6, 0x4c, 0xd1, 0x5e, 0x60, 0xa9, + ], + [ + 0xdb, 0xb5, 0xd7, 0x61, 0x38, 0xd5, 0x72, 0x48, 0xb2, 0xc7, 0x8d, 0x6a, 0xaf, + 0xff, 0xfd, 0x28, 0x52, 0x6c, 0x12, 0x84, 0x9a, 0xd4, 0xb6, 0x4c, 0x9b, 0xdb, + 0x2a, 0xf7, 0x8c, 0x7d, 0x93, 0xb9, + ], + [ + 0x1f, 0x47, 0x25, 0xfd, 0x3a, 0x34, 0x91, 0xf6, 0x46, 0x8e, 0x05, 0xad, 0xeb, + 0x19, 0x34, 0x0b, 0x77, 0x16, 0xec, 0xf1, 0x8d, 0xfd, 0xf8, 0x3d, 0x64, 0xcb, + 0x43, 0xf4, 0xe9, 0xfb, 0xde, 0x78, 0xfd, 0x5b, 0x0b, 0xcf, 0xcb, 0x1b, 0x55, + 0x52, 0x67, 0xe0, 0x39, 0x08, 0x07, 0x00, 0x7a, 0x6a, + ], + [ + 0xff, 0xac, 0xcc, 0xc4, 0x5d, 0x2e, 0xac, 0x44, 0xb2, 0x00, 0xe8, 0x5d, 0xe9, + 0xcc, 0xab, 0x34, 0x25, 0x33, 0x35, 0x02, 0x2c, 0x6d, 0x4f, 0x9f, 0x8f, 0x44, + 0x80, 0xb5, 0x1d, 0x96, 0x0d, 0xb9, 0xdc, 0xc9, 0x87, 0x87, 0x90, 0x5c, 0xb4, + 0x99, 0x2d, 0xd9, 0x27, 0xe6, 0x2b, 0x44, 0x4d, 0xf7, 0x4a, 0x09, 0xd3, 0x96, + 0x2c, 0x56, 0xd5, 0xbe, 0x61, 0xd9, 0x66, 0x25, 0xcd, 0x5a, 0x15, 0xb4, + ] + ), + test_case!( + [ + 0x02, 0xd3, 0xa6, 0xc6, 0x81, 0xfb, 0x18, 0x43, 0xf4, 0xf4, 0x43, 0xf8, 0x0b, + 0xd6, 0x9f, 0xda, 0x40, 0x8a, 0x16, 0xf8, 0x9e, 0x8c, 0x7f, 0xcd, 0x09, 0x05, + 0x49, 0x34, 0xe3, 0x4e, 0x88, 0xc7, 0x4d, 0xb3, 0x75, 0x14, 0x01, 0xa7, 0x24, + 0x53, 0xfd, 0x74, 0x8b, 0xc5, 0x29, 0x32, 0x1b, 0xd7, 0x7a, 0xe8, 0xcd, 0xb3, + 0x93, 0xfe, 0x08, 0xd2, 0x23, 0xd0, 0x7e, 0xfa, 0x42, 0xe0, 0x22, 0xd9, 0x07, + 0x13, 0x45, 0x44, 0xa7, 0xec, 0x16, 0x9a, 0x5e, 0x40, 0x23, 0xc9, 0xc6, 0x34, + 0x71, 0x85, 0x28, 0x19, 0x2c, 0xf2, 0xd5, 0xdf, 0xb9, 0xb4, 0x7a, 0x89, 0x80, + 0x84, 0x35, 0xb5, 0x45, 0x47, 0xff, 0x0d, 0xc1, 0x0d, 0xf7, 0x90, 0xb0, 0x74, + 0x34, 0x90, 0xf2, 0x60, 0x76, 0xdc, 0xd9, 0xc2, 0xfd, 0x9e, 0x3c, 0xbf, 0x6c, + 0xd1, 0xa0, 0x14, 0x7a, 0x51, 0xdb, 0x8a, + ], + [ + 0x09, 0x96, 0x75, 0xe1, 0x79, 0xa2, 0xb8, 0x75, 0x8c, 0x75, 0x3c, 0x68, 0x22, + 0xdd, 0x3a, 0xaa, 0x65, 0x80, 0x02, 0xc6, + ], + [ + 0x36, 0x64, 0xd4, 0xe4, 0xb5, 0x7d, 0x8a, 0xdc, 0x8d, 0x9c, 0x63, 0xc1, 0xd1, + 0xf4, 0xc4, 0x01, 0x2f, 0xaa, 0xcf, 0xc2, 0x1d, 0xc3, 0xc5, 0xed, 0x83, 0xd2, + 0x5f, 0xe3, 0xff, 0x18, 0x29, 0x03, + ], + [ + 0x94, 0xfc, 0xb9, 0xb8, 0x0f, 0x81, 0xf4, 0x42, 0xf9, 0x34, 0xf7, 0xed, 0x5a, + 0xc0, 0x67, 0xa6, 0x77, 0x21, 0xbd, 0x72, 0x26, 0x2c, 0x98, 0xfd, 0x99, 0x48, + 0xe5, 0x19, 0xa2, 0xd2, 0xda, 0xc3, 0xf7, 0xe0, 0x13, 0xa5, 0x84, 0xeb, 0xa9, + 0x28, 0x38, 0x76, 0x8a, 0xa5, 0x7d, 0xdf, 0xd1, 0x23, + ], + [ + 0x52, 0x1c, 0x97, 0xac, 0xc3, 0x0d, 0x13, 0x19, 0xcd, 0x3c, 0x10, 0x4c, 0x89, + 0x67, 0x49, 0x59, 0xad, 0x14, 0xbe, 0xc9, 0xf6, 0x46, 0xb8, 0xb6, 0x3b, 0x3d, + 0x29, 0xc8, 0x03, 0x00, 0x00, 0x6e, 0x5e, 0x41, 0x5d, 0xf8, 0xae, 0x2e, 0x4f, + 0x80, 0x6c, 0x0d, 0x8d, 0xe9, 0x65, 0x5a, 0xba, 0x13, 0x89, 0xc1, 0xc5, 0x28, + 0x2b, 0x0b, 0x42, 0x34, 0xab, 0x3f, 0x6c, 0xba, 0x3e, 0x71, 0x30, 0x5e, + ] + ), + test_case!( + [ + 0x52, 0x71, 0x17, 0x1e, 0xa3, 0x8b, 0xe0, 0x4c, 0x92, 0xe6, 0xf5, 0x6e, 0xe4, + 0xf5, 0xab, 0xc4, 0x94, 0x29, 0x9b, 0xa6, 0x09, 0x44, 0x5e, 0xe0, 0x54, 0x3f, + 0x1d, 0xa8, 0x67, 0xe6, 0xb7, 0x94, 0x9d, 0x32, 0x5f, 0x40, 0x56, 0x0e, 0x6a, + 0xfd, 0xab, 0x54, 0xb2, 0x26, 0xae, 0xa0, 0xe7, 0x02, 0x78, 0x7b, 0x4c, 0xf4, + 0x88, 0xe6, 0x96, 0xe0, 0x91, 0xa9, 0x1f, 0xb8, 0x8f, 0x2e, 0x63, 0xd3, 0xe4, + 0x9f, 0xdf, 0xdb, 0x69, 0x60, 0xd0, 0xb2, 0x32, 0x57, 0xa9, 0x13, 0xc0, 0x1c, + 0x7a, 0x89, 0x2f, 0x6d, 0x3c, 0x27, 0x95, 0xae, 0x4b, 0x75, 0xb8, 0xdb, 0x97, + 0x6b, 0xf2, 0xea, 0x92, 0xfc, 0xb3, 0xf0, 0x57, 0xf8, 0x29, 0xcf, 0x49, 0x86, + 0x3a, 0xa3, 0x80, 0x9b, 0x60, 0x2f, 0xc3, 0xce, 0xe6, 0x3f, 0x18, 0x00, 0x20, + 0xf4, 0x48, 0x8e, 0x4a, 0xf2, 0xf3, 0x07, 0x2f, + ], + [ + 0x37, 0x28, 0xa7, 0x30, 0x08, 0xfd, 0x65, 0xf8, 0xc9, 0xb3, 0x6c, 0x77, 0x7a, + 0xe3, 0x57, 0x5b, 0xd3, 0x96, 0x90, 0x0f, + ], + [ + 0xfe, 0x48, 0xad, 0xe6, 0xea, 0xfe, 0x62, 0x31, 0xb6, 0x47, 0x90, 0x3e, 0x16, + 0xc5, 0xec, 0x5b, 0x1b, 0x97, 0x36, 0xd1, 0x8f, 0xc6, 0x5d, 0xb0, 0x08, 0xa5, + 0x7d, 0xe4, 0xbd, 0x8c, 0x69, 0x83, + ], + [ + 0x7d, 0xea, 0x9e, 0xa0, 0x7a, 0x8c, 0xc7, 0x0f, 0x7f, 0x29, 0xfb, 0xfa, 0x76, + 0xf2, 0x3e, 0x59, 0xc0, 0xd0, 0x51, 0xa6, 0x5b, 0x6f, 0x54, 0x4e, 0x6b, 0x2e, + 0xc8, 0x4c, 0x12, 0x69, 0x1e, 0x3e, 0x10, 0x48, 0x88, 0xbb, 0x23, 0x13, 0xae, + 0xd4, 0xfd, 0x7b, 0x0c, 0x4a, 0x97, 0xbd, 0xd7, 0x0d, + ], + [ + 0x26, 0xd5, 0xab, 0x59, 0x27, 0x26, 0xa4, 0x6a, 0x3f, 0x68, 0xb3, 0xeb, 0xb6, + 0x56, 0xf5, 0x86, 0xb7, 0xa1, 0x83, 0x45, 0xc0, 0xd6, 0x70, 0xc0, 0x53, 0x93, + 0x97, 0x3b, 0xbe, 0x31, 0x68, 0x12, 0x5e, 0xcf, 0x81, 0xeb, 0x9f, 0xad, 0x05, + 0xba, 0x6a, 0x71, 0xb4, 0x3f, 0xc6, 0x37, 0x37, 0xda, 0x8a, 0xfd, 0x72, 0xc7, + 0x64, 0xdd, 0xc8, 0x03, 0x6c, 0x2c, 0xe5, 0x6c, 0x31, 0x96, 0x43, 0x4c, + ] + ), + test_case!( + [ + 0xa2, 0x1f, 0x1d, 0xbf, 0xa8, 0x19, 0xdc, 0x26, 0x18, 0x5c, 0x30, 0x7c, 0x04, + 0xb0, 0x24, 0x95, 0xc3, 0x2c, 0x0b, 0x28, 0xc5, 0xe4, 0xad, 0x7e, 0x0c, 0xf5, + 0x17, 0x8c, 0xd8, 0x3c, 0xe7, 0xf7, 0xa2, 0x4a, 0x11, 0x50, 0xac, 0x0b, 0x76, + 0x37, 0xfb, 0x14, 0x59, 0x50, 0x66, 0x76, 0x8d, 0x32, 0x68, 0xff, 0x06, 0x82, + 0xa4, 0xed, 0x19, 0x74, 0x2a, 0x49, 0x1e, 0xa4, 0xe1, 0x04, 0x85, 0xad, 0x9c, + 0xcf, 0x4b, 0x7c, 0x18, 0x76, 0x0d, 0xda, 0xbb, 0x27, 0x4f, 0xdd, 0x29, 0x5d, + 0xc7, 0xe8, 0x45, 0x47, 0x7c, 0xe4, 0x6f, 0xb8, 0x1f, 0xc1, 0xb1, 0x9b, 0x5d, + 0x83, 0x40, 0x75, 0xf6, 0x97, 0x11, 0x06, 0xd4, 0x03, 0x9f, 0x8b, 0x46, 0x0a, + 0xe9, 0xdd, 0xcc, 0x73, 0xa9, 0x26, 0xec, 0x06, 0x82, 0xa1, 0x2f, 0xc1, 0x9e, + 0xbe, 0x81, 0x92, 0x75, 0x6e, 0x00, 0x10, 0x3d, 0x0c, + ], + [ + 0x2e, 0x19, 0xba, 0x7d, 0x5f, 0x43, 0x6f, 0x2c, 0x78, 0x46, 0x0d, 0x60, 0xa3, + 0x4b, 0x44, 0xb5, 0x82, 0x94, 0x98, 0xfc, + ], + [ + 0xa1, 0x7b, 0xe9, 0xb2, 0x58, 0xb1, 0xe0, 0xa0, 0xb4, 0xa0, 0x53, 0x84, 0x8e, + 0x25, 0xb0, 0xf1, 0xbd, 0x30, 0x7f, 0x66, 0x4c, 0x99, 0xbf, 0xaf, 0x5b, 0x2d, + 0x82, 0x8b, 0xef, 0x08, 0x4e, 0x2d, + ], + [ + 0x01, 0xd0, 0x3c, 0xf8, 0xe7, 0x90, 0x54, 0x62, 0x95, 0xef, 0xc3, 0x35, 0x6a, + 0x9f, 0x6b, 0x49, 0x9c, 0x3a, 0x44, 0x5e, 0xa6, 0x62, 0x21, 0x81, 0xd7, 0xae, + 0xad, 0xba, 0xd3, 0x20, 0x97, 0xa3, 0xc2, 0xbb, 0x26, 0xa7, 0x80, 0x73, 0xc6, + 0xb0, 0x78, 0xf1, 0x4b, 0x9f, 0xbc, 0xe8, 0x69, 0x77, + ], + [ + 0x91, 0x5f, 0x90, 0xe3, 0x8d, 0x1f, 0xa0, 0xf6, 0x53, 0x71, 0x7c, 0x05, 0x9d, + 0x85, 0x50, 0xf3, 0x59, 0xe4, 0xaa, 0x98, 0x59, 0x33, 0x59, 0x30, 0x7e, 0x56, + 0x00, 0x93, 0xa4, 0xf1, 0xb5, 0x05, 0x0d, 0xad, 0xb6, 0xdf, 0x7e, 0xea, 0x32, + 0xb9, 0xfb, 0xd2, 0x48, 0x2f, 0x1d, 0xc8, 0x98, 0x3b, 0x51, 0xe2, 0xdb, 0x88, + 0xf5, 0x61, 0xcf, 0x3d, 0x85, 0x6f, 0x6f, 0xfc, 0x50, 0x35, 0x4c, 0xc4, + ] + ), + test_case!( + [ + 0x11, 0xf6, 0x3f, 0x5c, 0x17, 0x7b, 0x67, 0x52, 0x23, 0x61, 0x77, 0x79, 0xef, + 0x95, 0xf6, 0xe1, 0xca, 0x73, 0xbf, 0x4f, 0xe9, 0xd1, 0x00, 0x37, 0xc0, 0x23, + 0x2f, 0x85, 0xb8, 0xb6, 0xa0, 0x54, 0x83, 0x36, 0x02, 0xe3, 0xb5, 0x7b, 0xc3, + 0x9c, 0x72, 0xc4, 0x4b, 0x90, 0x64, 0x46, 0x63, 0xa5, 0x6a, 0x76, 0x5e, 0x9a, + 0x78, 0xeb, 0xa1, 0x1b, 0x94, 0xde, 0x9a, 0x35, 0x29, 0x61, 0x3f, 0x76, 0xb9, + 0xdf, 0x8e, 0x49, 0x47, 0xe4, 0x0c, 0xd4, 0xcc, 0x5e, 0xda, 0x97, 0xda, 0x89, + 0xcd, 0xe6, 0x9e, 0x43, 0x58, 0x1b, 0x15, 0x0d, 0x5a, 0x3a, 0xe8, 0xdd, 0x71, + 0xa9, 0xbe, 0x0c, 0x10, 0xea, 0x95, 0xc2, 0x45, 0x72, 0xdf, 0xf0, 0xb6, 0xf2, + 0xb1, 0x2d, 0x80, 0xe0, 0x08, 0x54, 0xc9, 0x54, 0xdf, 0xb7, 0x40, 0xb2, 0x3b, + 0x67, 0xa2, 0x61, 0x08, 0x78, 0x1e, 0x46, 0xfe, 0x1a, 0x5a, + ], + [ + 0xd7, 0x7a, 0xd5, 0xf6, 0xf9, 0xb6, 0xff, 0xd6, 0x41, 0x81, 0x23, 0xa3, 0xa3, + 0xcd, 0x4c, 0x43, 0x3b, 0x65, 0x62, 0xe7, + ], + [ + 0xbc, 0xaf, 0xe5, 0x98, 0x2f, 0x9d, 0x5b, 0xf6, 0x33, 0x40, 0x37, 0xbc, 0x64, + 0x7e, 0x34, 0x59, 0xf9, 0xcf, 0x91, 0xb3, 0x87, 0xd8, 0x8c, 0x20, 0x69, 0x93, + 0x5b, 0xb5, 0x86, 0x55, 0x4c, 0x39, + ], + [ + 0xa7, 0x8f, 0xd1, 0xbd, 0xf8, 0x42, 0x56, 0x3d, 0x3d, 0xcc, 0xe2, 0x17, 0x29, + 0x80, 0xf6, 0x3d, 0xa7, 0x13, 0x28, 0x2e, 0x26, 0xe1, 0x06, 0x92, 0x1f, 0x24, + 0x45, 0xfb, 0x11, 0x84, 0xb0, 0xe8, 0x2c, 0xc0, 0xb5, 0xec, 0xd9, 0xdb, 0x56, + 0xa8, 0x7d, 0x34, 0x0d, 0x31, 0xf3, 0x63, 0xa0, 0x31, + ], + [ + 0xd5, 0x7c, 0xc3, 0xf0, 0x6b, 0x67, 0xc9, 0x0b, 0x56, 0x50, 0x3d, 0x47, 0xfa, + 0x14, 0xf3, 0xac, 0xca, 0xb1, 0xb6, 0xa0, 0x15, 0xc6, 0x1f, 0x38, 0x53, 0x5f, + 0xec, 0xd7, 0x2b, 0x3c, 0x0a, 0x45, 0xa7, 0x6d, 0x17, 0xe1, 0x66, 0x76, 0xcd, + 0xd1, 0x68, 0x9c, 0x5a, 0xed, 0xe3, 0x85, 0x57, 0xc9, 0xb7, 0xd4, 0x84, 0x7a, + 0x70, 0x0d, 0x4c, 0xaa, 0x58, 0xdc, 0xea, 0xf1, 0x6c, 0xd9, 0xfe, 0x81, + ] + ), + test_case!( + [ + 0x5e, 0x94, 0x43, 0x8d, 0xa3, 0x9d, 0x5b, 0xfc, 0xcc, 0x3c, 0x68, 0xfb, 0xe7, + 0x50, 0xba, 0x4e, 0x15, 0x6f, 0x7a, 0xd6, 0xf0, 0x16, 0xaa, 0xda, 0xd2, 0x95, + 0xc7, 0x2f, 0x17, 0x7f, 0x3f, 0xae, 0xa5, 0x09, 0x19, 0x50, 0x97, 0x33, 0x1e, + 0x75, 0x3d, 0xa2, 0x37, 0x3b, 0x05, 0x46, 0xc1, 0xa8, 0x38, 0xa1, 0x44, 0xcd, + 0xf8, 0x4b, 0x8c, 0x55, 0xda, 0x6a, 0x24, 0xf0, 0xba, 0x57, 0xc8, 0xfb, 0x4c, + 0x9a, 0xe3, 0x90, 0xf7, 0x72, 0xe7, 0x52, 0x0f, 0x30, 0x7b, 0xc1, 0x21, 0x7d, + 0xce, 0xa9, 0x03, 0x72, 0x58, 0x3a, 0x69, 0x16, 0xa8, 0x06, 0xc7, 0x54, 0x0a, + 0xd9, 0xe8, 0x24, 0x62, 0xca, 0x70, 0x6c, 0x83, 0xa0, 0x38, 0x4a, 0xbb, 0x64, + 0x93, 0x7a, 0x4a, 0xad, 0xf3, 0x4f, 0x69, 0xc6, 0xa0, 0x79, 0x46, 0x36, 0x89, + 0xbc, 0x20, 0x97, 0xd8, 0x39, 0x72, 0x80, 0x48, 0x3a, 0xb2, 0x02, + ], + [ + 0x9a, 0xe9, 0x8b, 0xe9, 0xf1, 0x3a, 0x2e, 0xe0, 0x83, 0x5d, 0x8c, 0x53, 0xd2, + 0xcf, 0xe3, 0x27, 0xb9, 0x08, 0x1d, 0xc7, + ], + [ + 0x1c, 0xf3, 0x32, 0x90, 0x6d, 0x9e, 0x0f, 0x30, 0x81, 0x75, 0xf5, 0xbc, 0x7d, + 0xcc, 0xd4, 0x79, 0xa1, 0xf2, 0xfc, 0xfb, 0xc6, 0xf2, 0x40, 0xb0, 0x41, 0xb9, + 0xa0, 0x60, 0x98, 0x24, 0x7d, 0x96, + ], + [ + 0x5c, 0xb0, 0x2f, 0xff, 0x06, 0x0b, 0xbc, 0x64, 0x8b, 0x8b, 0x8f, 0x47, 0x26, + 0x8c, 0x82, 0xfd, 0x70, 0x0d, 0x9e, 0x53, 0xf2, 0x08, 0x3b, 0x56, 0xb1, 0x26, + 0xa2, 0x98, 0x68, 0x80, 0xd7, 0x4f, 0x53, 0xf5, 0x57, 0x87, 0x12, 0x3d, 0xcc, + 0xfd, 0xe0, 0x69, 0x27, 0x08, 0x84, 0xb3, 0x3c, 0x41, + ], + [ + 0x6b, 0xb5, 0xb1, 0xcc, 0xa3, 0x0e, 0xa2, 0xdf, 0x18, 0x4f, 0x25, 0x61, 0xae, + 0xfa, 0x1c, 0x1d, 0x19, 0xb6, 0x9b, 0x33, 0xf9, 0xa6, 0xfd, 0x96, 0xc3, 0xd7, + 0x06, 0xb0, 0x82, 0x32, 0xa1, 0xba, 0x49, 0xbc, 0xda, 0xdb, 0x02, 0x2d, 0xbf, + 0x4c, 0xf6, 0x20, 0xab, 0x41, 0xd1, 0xbe, 0x75, 0xbf, 0xab, 0xbb, 0xd9, 0x54, + 0x11, 0x24, 0x87, 0xb5, 0xbe, 0x57, 0xbd, 0xca, 0xd8, 0xa9, 0x22, 0x6c, + ] + ), + ]; + } +}
diff --git a/src/hmac.rs b/src/hmac.rs new file mode 100644 index 0000000..2a32cf5 --- /dev/null +++ b/src/hmac.rs
@@ -0,0 +1,4220 @@ +// Copyright 2018 Google LLC +// +// Use of this source code is governed by an MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT. + +//! Hash-based Message Authentication Codes (HMACs). + +use std::fmt::{self, Debug, Formatter}; +use std::marker::PhantomData; + +use boringssl::{self, CStackWrapper}; +use hash::{inner::Digest, Hasher, Sha256, Sha384, Sha512}; + +/// A Hash-based Message Authentication Code (HMAC). +/// +/// `Hmac` is an HMAC over the hash function `H`. +#[must_use] +pub struct Hmac<H: Hasher> { + ctx: CStackWrapper<boringssl::HMAC_CTX>, + _marker: PhantomData<H>, +} + +impl<H: Hasher> Hmac<H> { + /// Constructs a new HMAC. + #[must_use] + pub fn new(key: &[u8]) -> Hmac<H> { + // TODO(joshlf): Do we want to put any constraints on what constitutes a + // valid key? + Hmac { + // hmac_ctx_new can only fail due to OOM + ctx: CStackWrapper::hmac_ctx_new(key, &H::evp_md()).unwrap(), + _marker: PhantomData, + } + } + + /// Adds bytes to the HMAC. + pub fn update(&mut self, bytes: &[u8]) { + self.ctx.hmac_update(bytes); + } + + /// Returns the HMAC of the bytes added so far. + #[must_use] + pub fn finish(mut self) -> H::Digest { + let mut out = H::Digest::zero(); + self.ctx.hmac_final(out.as_mut()); + out + } +} + +impl<H: Hasher> Debug for Hmac<H> { + fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> { + write!(f, "Hmac") + } +} + +/// HMAC-SHA256. +pub type HmacSha256 = Hmac<Sha256>; +/// HMAC-SHA384. +pub type HmacSha384 = Hmac<Sha384>; +/// HMAC-SHA512. +pub type HmacSha512 = Hmac<Sha512>; + +/// Computes the HMAC of a sequence of bytes under a key. +/// +/// `hmac` creates a new instance of `Hmac<H>` using the key `key`, adds `bytes` +/// to it, and then computes the HMAC. +#[must_use] +pub fn hmac<H: Hasher>(key: &[u8], bytes: &[u8]) -> H::Digest { + let mut hmac = Hmac::<H>::new(key); + hmac.update(bytes); + hmac.finish() +} + +#[cfg(feature = "insecure")] +pub(crate) mod insecure_hmac_sha1 { + #[allow(deprecated)] + use hash::{insecure_sha1_digest::InsecureSha1Digest, InsecureSha1}; + use hmac::Hmac; + + // NOTE(joshlf): It's important that InsecureHmacSha1 is a new type rather + // than a type alias for Hmac<Sha1>. If it were the latter, then client code + // could use this to coax a type parameter into taking on the type Sha1, and + // could thus construct SHA-1 hashes directly, which we explicitly wish to + // avoid. + + /// INSECURE: The Hash-based Message Authentication Code (HMAC) over SHA-1. + /// + /// # Security + /// + /// HMAC-SHA1 is considered insecure, and should only be used for compatibility + /// with legacy applications. + #[deprecated(note = "HMAC-SHA1 is considered insecure")] + pub struct InsecureHmacSha1 { + #[allow(deprecated)] + hmac: Hmac<InsecureSha1>, + } + + #[allow(deprecated)] + impl InsecureHmacSha1 { + /// INSECURE: Constructs a new HMAC-SHA1. + /// + /// # Security + /// + /// HMAC-SHA1 is considered insecure, and should only be used for + /// compatibility with legacy applications. + #[must_use] + #[deprecated(note = "HMAC-SHA1 is considered insecure")] + pub fn insecure_new(key: &[u8]) -> InsecureHmacSha1 { + InsecureHmacSha1 { + hmac: Hmac::new(key), + } + } + + /// INSECURE: Adds bytes to the HMAC-SHA1. + /// + /// # Security + /// + /// HMAC-SHA1 is considered insecure, and should only be used for + /// compatibility with legacy applications. + #[must_use] + #[deprecated(note = "HMAC-SHA1 is considered insecure")] + pub fn insecure_update(&mut self, bytes: &[u8]) { + self.hmac.update(bytes); + } + + /// INSECURE: Returns the HMAC-SHA1 of the bytes added so far. + /// + /// # Security + /// + /// HMAC-SHA1 is considered insecure, and should only be used for + /// compatibility with legacy applications. + #[must_use] + #[deprecated(note = "HMAC-SHA1 is considered insecure")] + pub fn insecure_finish(self) -> InsecureSha1Digest { + self.hmac.finish() + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + #[cfg(feature = "insecure")] + #[allow(deprecated)] + use hash::insecure_sha1_digest::InsecureSha1Digest; + use hash::*; + + #[test] + fn test_hmac() { + struct TestCase { + input: &'static [u8], + #[cfg(feature = "insecure")] + #[allow(deprecated)] + sha1: <InsecureSha1 as Hasher>::Digest, + sha256: <Sha256 as Hasher>::Digest, + sha384: <Sha384 as Hasher>::Digest, + sha512: <Sha512 as Hasher>::Digest, + } + + for case in TEST_CASES.iter() { + fn test<H: Hasher>(input: &'static [u8], digest: &H::Digest) { + assert_eq!(&hmac::<H>(TEST_KEY, input), digest, "input: {:?}", input); + // Test that adding bytes incrementally works too. + let mut hmac = Hmac::<H>::new(TEST_KEY); + for b in input { + hmac.update(&[*b]); + } + assert_eq!(&hmac.finish(), digest, "input: {:?}", input); + } + #[cfg(feature = "insecure")] + #[allow(deprecated)] + test::<InsecureSha1>(case.input, &case.sha1); + test::<Sha256>(case.input, &case.sha256); + test::<Sha384>(case.input, &case.sha384); + test::<Sha512>(case.input, &case.sha512); + } + + macro_rules! test_case { + ($input:expr, $sha1:expr, $sha256:expr, $sha384:expr, $sha512:expr) => { + #[allow(deprecated)] + TestCase { + input: &$input, + #[cfg(feature = "insecure")] + sha1: InsecureSha1Digest($sha1), + sha256: Sha256Digest($sha256), + sha384: Sha384Digest($sha384), + sha512: Sha512Digest($sha512), + } + }; + } + + // These test cases were generated using the following script. Each is a + // randomly-generated input, with each length between 1 and 128 bytes + // represented. The constant key "1482318330" is used. + // + // # Generate 10000 bytes/20000 hex characters of random data + // function rand { dd if=/dev/urandom bs=1 count=10000 | hexdump -ve '1/1 "%.2x"'; } + // + // # Convert hex to raw bytes + // function hex_to_bytes { perl -pe 's/([0-9a-f]{2})/chr hex $1/gie'; } + // + // # Convert hex to a Rust array + // function hex_to_array { echo -n "["; while read -n 2 c; do echo -n "0x${c},"; + // done; echo "]"; } + // + // # Usage: hmac <input-hex> <hash> + // function hmac { echo -n $(echo -n "$1" | hex_to_bytes | openssl dgst "-${2}" \ + // -hmac 1482318330 | cut -d ' ' -f 1) | hex_to_array; } + // + // # Only even numbers of hex characters + // for i in `seq 2 2 256`; do + // INPUT=$(rand 2>/dev/null | head -c $i); + // echo 'test_case!'"($(echo -n ${INPUT} | hex_to_array), $(hash ${INPUT} 1), \ + // $(hash ${INPUT} 256), $(hash ${INPUT} 384), $(hash ${INPUT} 512)),"; + // done + + const TEST_KEY: &[u8] = b"1482318330"; + + const TEST_CASES: &[TestCase] = &[ + test_case!( + [0x23,], + [ + 0x30, 0xac, 0xcf, 0x23, 0x2c, 0x40, 0x44, 0x84, 0xaf, 0x03, 0xc7, 0x62, 0xb9, + 0x28, 0x90, 0x50, 0x39, 0x23, 0x80, 0x30, + ], + [ + 0x4a, 0xb9, 0xf8, 0x04, 0xa0, 0x53, 0x6f, 0x10, 0x36, 0xe6, 0x76, 0x93, 0x6c, + 0xea, 0x6f, 0x4d, 0x0c, 0xe4, 0x27, 0x88, 0x45, 0x06, 0x3a, 0x88, 0x92, 0x95, + 0x5f, 0x15, 0x9d, 0x89, 0x37, 0x88, + ], + [ + 0xea, 0xc0, 0xf9, 0x95, 0xca, 0x06, 0x14, 0xd2, 0xc5, 0x0b, 0x7c, 0x82, 0xd0, + 0xfd, 0x81, 0x16, 0x8e, 0x05, 0xdd, 0x2b, 0xe4, 0xf8, 0x16, 0xd7, 0xa7, 0x77, + 0xaa, 0xf1, 0x5f, 0x40, 0xb3, 0xf0, 0xa3, 0x51, 0x48, 0x38, 0x2d, 0x24, 0x1f, + 0x65, 0x8f, 0x11, 0x43, 0x06, 0xf0, 0x8c, 0x67, 0x5d, + ], + [ + 0x8d, 0x58, 0x3f, 0xeb, 0x28, 0x38, 0x9c, 0xb2, 0xf6, 0x03, 0xbe, 0x8c, 0x26, + 0xa8, 0x7d, 0x44, 0x69, 0x8b, 0xe0, 0x81, 0x74, 0x53, 0x7f, 0xbf, 0x73, 0xa3, + 0x0f, 0xfd, 0x5a, 0x50, 0x4d, 0x3b, 0x45, 0xf8, 0x65, 0x5d, 0xdc, 0x40, 0x4d, + 0xa4, 0xf3, 0xb5, 0x06, 0x52, 0x36, 0x48, 0x36, 0xa6, 0x61, 0x77, 0x45, 0x31, + 0x11, 0x14, 0xb1, 0x05, 0xe3, 0xca, 0x4a, 0x4c, 0x10, 0x7e, 0xf7, 0xdc, + ] + ), + test_case!( + [0xbd, 0xcb,], + [ + 0x89, 0x5d, 0xc2, 0xaf, 0x01, 0xbf, 0x7b, 0xa4, 0x35, 0x8c, 0x64, 0xaf, 0x66, + 0xc1, 0x74, 0x34, 0x98, 0x57, 0x41, 0xb6, + ], + [ + 0xdd, 0x4b, 0x13, 0x72, 0x7d, 0x33, 0x53, 0x5f, 0xe7, 0x1c, 0x42, 0x1c, 0x3d, + 0xae, 0xf9, 0x86, 0x98, 0x01, 0x06, 0xfe, 0xf8, 0x71, 0x71, 0xd5, 0xfb, 0x2c, + 0xe7, 0x43, 0x88, 0x0a, 0x90, 0x32, + ], + [ + 0x0f, 0xdc, 0x20, 0x3d, 0x8c, 0xca, 0xea, 0xb1, 0x94, 0x7e, 0x86, 0x0c, 0x49, + 0xfe, 0x83, 0xe2, 0x71, 0x20, 0xf3, 0x5a, 0x29, 0x3c, 0xbb, 0xa5, 0x94, 0x83, + 0x76, 0x3d, 0x76, 0x28, 0x23, 0x48, 0xcd, 0x41, 0xb2, 0x19, 0x79, 0x38, 0x66, + 0x1c, 0xe4, 0x49, 0xe0, 0x2f, 0x31, 0x1c, 0x06, 0x1d, + ], + [ + 0xa2, 0x02, 0x5d, 0x9f, 0xaa, 0x17, 0x2d, 0xdc, 0xe0, 0xd6, 0xd7, 0xf8, 0x38, + 0x27, 0x79, 0x02, 0x1c, 0x96, 0xe7, 0xdb, 0xf7, 0x34, 0x61, 0x9f, 0x59, 0xdb, + 0xca, 0x05, 0x1d, 0x2c, 0xe9, 0x61, 0x5b, 0xe0, 0xc8, 0x3d, 0x21, 0x2e, 0x07, + 0xc6, 0x64, 0x1a, 0xb4, 0xff, 0xd8, 0x85, 0xb4, 0xaf, 0x00, 0x36, 0x4d, 0x8a, + 0x50, 0x29, 0x7d, 0xc8, 0x57, 0x08, 0x99, 0xb8, 0x39, 0x3d, 0xc0, 0x3d, + ] + ), + test_case!( + [0x2d, 0xfb, 0xa3,], + [ + 0x95, 0x0d, 0xeb, 0xd1, 0x73, 0x6d, 0x4e, 0x81, 0xd3, 0x55, 0x48, 0x4d, 0xba, + 0x76, 0xad, 0x38, 0x21, 0xa1, 0x1b, 0x39, + ], + [ + 0x11, 0xba, 0x3b, 0x67, 0x72, 0x41, 0x3b, 0x86, 0x01, 0x34, 0x82, 0x3a, 0xb7, + 0xdd, 0xa7, 0xc2, 0xd7, 0xa1, 0x95, 0xd5, 0x7a, 0xba, 0xc8, 0xe0, 0xeb, 0xbe, + 0xac, 0x81, 0x9d, 0x2d, 0x96, 0xd5, + ], + [ + 0x31, 0x4f, 0xff, 0x7e, 0x9f, 0xb8, 0xcc, 0x0e, 0x0f, 0xeb, 0xb6, 0xbe, 0xb5, + 0xd4, 0x9c, 0xf7, 0x59, 0x95, 0x61, 0xc7, 0xa9, 0xcd, 0x69, 0x0e, 0xa2, 0xbd, + 0x63, 0xad, 0x22, 0x54, 0x86, 0x7c, 0xd8, 0x32, 0xfc, 0x76, 0x12, 0xd4, 0xa3, + 0x11, 0x97, 0x24, 0xe9, 0xa9, 0xb0, 0x21, 0xc4, 0x16, + ], + [ + 0xd5, 0x6d, 0x41, 0xc0, 0x89, 0xaa, 0x77, 0x64, 0x32, 0xe5, 0x9d, 0xec, 0x92, + 0xf2, 0xf6, 0x9e, 0x8c, 0x1f, 0xe4, 0xea, 0xd1, 0x36, 0xa7, 0x3f, 0x89, 0x5f, + 0xee, 0xde, 0x5c, 0xdf, 0x3a, 0xb8, 0xe8, 0xe3, 0xfe, 0xd5, 0x4e, 0x37, 0xe0, + 0x01, 0xb7, 0xba, 0x17, 0x27, 0xb2, 0x51, 0x73, 0x40, 0x9e, 0x94, 0xd2, 0x0e, + 0x38, 0x99, 0x8c, 0x67, 0x8a, 0xaf, 0x9d, 0xb3, 0x79, 0xd9, 0xb1, 0xa9, + ] + ), + test_case!( + [0x37, 0x6e, 0xf5, 0x7a,], + [ + 0x14, 0xb0, 0x4a, 0x22, 0x21, 0xbf, 0x4f, 0xb1, 0x87, 0x25, 0x2f, 0xa4, 0xee, + 0x52, 0xd7, 0x11, 0x70, 0x64, 0x74, 0xc1, + ], + [ + 0xa0, 0xbf, 0x6e, 0x1d, 0x18, 0x05, 0xfa, 0x54, 0x61, 0xed, 0xd6, 0x13, 0xc6, + 0xa9, 0x15, 0x92, 0xf0, 0xca, 0x57, 0x61, 0xa9, 0x06, 0x8e, 0x92, 0x0f, 0x01, + 0x0a, 0xd6, 0x0b, 0x86, 0x19, 0x17, + ], + [ + 0x14, 0x06, 0x7b, 0x95, 0xe3, 0xc6, 0x9f, 0x9d, 0x37, 0xe8, 0x16, 0x83, 0xcd, + 0x27, 0x66, 0x21, 0x0e, 0x18, 0x88, 0x76, 0x82, 0x13, 0xdb, 0x94, 0xd5, 0x97, + 0x88, 0x02, 0x98, 0x4f, 0x05, 0x4f, 0xa2, 0x1b, 0x11, 0x11, 0xd0, 0x54, 0x3a, + 0x52, 0x4c, 0x3e, 0xaa, 0x03, 0x83, 0xea, 0xee, 0xd7, + ], + [ + 0xf1, 0xbb, 0x54, 0x7f, 0xde, 0x14, 0x79, 0x3e, 0x99, 0x3b, 0x06, 0x02, 0xa3, + 0x32, 0x8c, 0x8e, 0x6c, 0xd5, 0xdd, 0x2e, 0xe3, 0xcb, 0xd8, 0x14, 0x0c, 0x43, + 0x37, 0x95, 0xa0, 0x4c, 0xa8, 0x27, 0x58, 0x7a, 0x48, 0x3f, 0xd7, 0xb9, 0x0b, + 0x8e, 0x28, 0x9b, 0x1c, 0x8d, 0xa6, 0xf4, 0x73, 0x75, 0x35, 0x9a, 0x2d, 0x8d, + 0x01, 0x83, 0xb1, 0x4a, 0x47, 0x90, 0x6a, 0xb6, 0xb3, 0x02, 0xc0, 0x29, + ] + ), + test_case!( + [0x09, 0x62, 0xe5, 0x5e, 0xd1,], + [ + 0xe5, 0x12, 0x05, 0x77, 0xe0, 0x43, 0x43, 0x41, 0x29, 0xea, 0x5a, 0x04, 0x45, + 0xd1, 0xd2, 0xcc, 0x78, 0xd8, 0x25, 0xa9, + ], + [ + 0x89, 0xa5, 0x0c, 0xd3, 0xda, 0xb7, 0x67, 0xbe, 0x05, 0xb7, 0xcb, 0xc7, 0xf6, + 0x07, 0xf0, 0x12, 0x86, 0x3d, 0x36, 0x4b, 0x04, 0x78, 0xda, 0x8e, 0x0f, 0x1d, + 0x61, 0x62, 0xab, 0x66, 0x72, 0x7f, + ], + [ + 0xd1, 0x70, 0xe8, 0x76, 0xe9, 0x9b, 0x2b, 0x9d, 0x53, 0x24, 0x9d, 0x24, 0x65, + 0xab, 0x2e, 0x77, 0xe4, 0xbd, 0x8e, 0xcb, 0xa0, 0x0b, 0x03, 0xe8, 0xf0, 0x65, + 0x77, 0xff, 0xf9, 0x20, 0x14, 0xaa, 0xc5, 0x98, 0x7e, 0xd0, 0x3a, 0x93, 0x93, + 0x79, 0x13, 0x39, 0x6d, 0x78, 0xe8, 0x62, 0xf3, 0x47, + ], + [ + 0xdf, 0x20, 0x2a, 0x4f, 0x13, 0xec, 0xa8, 0x01, 0x1d, 0xa3, 0xe6, 0x8a, 0x1e, + 0x1d, 0xf4, 0xf6, 0x6b, 0x70, 0x63, 0x1f, 0xbb, 0x2e, 0x1b, 0x1f, 0x46, 0x01, + 0xb6, 0xa2, 0x22, 0x90, 0x6a, 0x80, 0xe7, 0x10, 0xb7, 0xe0, 0xf6, 0xa2, 0xd6, + 0x76, 0x0b, 0xc3, 0xae, 0x0a, 0x90, 0xe3, 0xee, 0x39, 0xbb, 0x77, 0xad, 0x9d, + 0x81, 0x0a, 0xde, 0x8d, 0xbf, 0xea, 0x98, 0x88, 0xb9, 0xa2, 0xf4, 0x61, + ] + ), + test_case!( + [0xd9, 0xd4, 0xc3, 0x4b, 0x3a, 0xcb,], + [ + 0x91, 0x62, 0xc5, 0xba, 0x27, 0xfa, 0x63, 0xe4, 0xec, 0x34, 0x37, 0xea, 0xd3, + 0x08, 0x06, 0xad, 0x0a, 0x19, 0x72, 0x7f, + ], + [ + 0x5f, 0xd4, 0xc5, 0x4f, 0x7e, 0x6d, 0xca, 0x1e, 0x8f, 0x0c, 0x62, 0x08, 0x16, + 0xbf, 0x14, 0xd9, 0x7c, 0x1f, 0x16, 0x29, 0x5e, 0xaa, 0x08, 0x52, 0x59, 0xe9, + 0x6b, 0x1d, 0xe6, 0xe8, 0xea, 0x03, + ], + [ + 0xb5, 0x6c, 0x7a, 0x32, 0xf2, 0xf8, 0x94, 0x8b, 0x7f, 0x35, 0xb8, 0x09, 0xec, + 0x99, 0x72, 0xd1, 0x58, 0x29, 0x69, 0xc9, 0x3c, 0xd8, 0x88, 0x8c, 0x06, 0xd5, + 0x7c, 0xf0, 0xee, 0x60, 0x7f, 0x91, 0x45, 0x99, 0x86, 0x31, 0x0a, 0xfa, 0x1c, + 0x1a, 0x3a, 0x09, 0x27, 0x0d, 0xbd, 0x90, 0xed, 0x28, + ], + [ + 0x62, 0xa4, 0x1e, 0x8a, 0x8d, 0xe6, 0xb9, 0x9d, 0xce, 0xc6, 0x24, 0x7c, 0x3f, + 0xfc, 0x45, 0x94, 0x72, 0xdd, 0xdc, 0xdd, 0x94, 0xb8, 0x01, 0xa1, 0x02, 0x12, + 0xa9, 0x60, 0x6a, 0x10, 0x9b, 0xa6, 0xff, 0xaa, 0x83, 0x8f, 0x61, 0x1c, 0xc3, + 0x2d, 0xc9, 0xe2, 0xbc, 0xc2, 0x94, 0x80, 0x3f, 0x15, 0x23, 0xab, 0xa0, 0x59, + 0x59, 0x05, 0xf9, 0xc4, 0x50, 0xe6, 0xd3, 0x01, 0xb0, 0xee, 0x1c, 0x89, + ] + ), + test_case!( + [0x36, 0x72, 0xd4, 0x9a, 0x29, 0xbf, 0x1d,], + [ + 0xc3, 0xb2, 0x4c, 0xfa, 0xeb, 0x2c, 0x76, 0x15, 0x94, 0xda, 0xb0, 0x10, 0x2f, + 0xa9, 0xbd, 0xad, 0x4b, 0x77, 0x04, 0xe1, + ], + [ + 0x75, 0x6d, 0x7b, 0x06, 0x50, 0xdb, 0x5c, 0xc8, 0xa5, 0xdd, 0xd8, 0xf8, 0x77, + 0x35, 0x40, 0x9e, 0x7f, 0xd2, 0x39, 0x2b, 0x67, 0xcb, 0x38, 0x45, 0xb6, 0xc7, + 0xf3, 0x5b, 0xc1, 0x95, 0xc4, 0x53, + ], + [ + 0x48, 0x86, 0x0a, 0xff, 0x63, 0x0b, 0x1c, 0x56, 0x50, 0x9f, 0x98, 0x03, 0xf0, + 0xb1, 0x5f, 0xca, 0x11, 0x05, 0xab, 0x38, 0x17, 0xd7, 0x27, 0x81, 0x01, 0x54, + 0x16, 0x95, 0x72, 0x3d, 0xba, 0x5f, 0x25, 0x42, 0xb6, 0x92, 0xf7, 0x8b, 0xf8, + 0xb8, 0xb2, 0x26, 0xe7, 0x4c, 0xf5, 0x4c, 0x6e, 0x74, + ], + [ + 0xcc, 0xc4, 0x8c, 0x19, 0x96, 0xc1, 0xc4, 0x93, 0x99, 0x81, 0x3b, 0x0b, 0x2f, + 0x05, 0xd5, 0x5f, 0x8c, 0xa4, 0xf2, 0x27, 0x06, 0xd2, 0xa7, 0xdc, 0xb7, 0x7e, + 0xab, 0x14, 0xf7, 0x9c, 0x7e, 0x6e, 0xfc, 0x87, 0x9f, 0xd1, 0x17, 0x13, 0xa6, + 0xf6, 0xd8, 0x05, 0x22, 0x66, 0x7a, 0x35, 0xe7, 0x1f, 0x7a, 0xfc, 0x52, 0xf1, + 0x45, 0xb1, 0xab, 0x7f, 0x2b, 0x25, 0x64, 0xca, 0x8e, 0x19, 0x8b, 0x82, + ] + ), + test_case!( + [0x42, 0x2e, 0xa1, 0xe3, 0xf4, 0x36, 0x10, 0x7f,], + [ + 0x30, 0xa1, 0x6c, 0x9c, 0xdd, 0xa3, 0xe5, 0xfc, 0x8f, 0x98, 0x50, 0xbc, 0xc4, + 0xe1, 0x74, 0x7d, 0x6e, 0x24, 0xd2, 0x8f, + ], + [ + 0x19, 0xf4, 0xfb, 0xed, 0x7f, 0x6d, 0xb4, 0xb4, 0x89, 0x3c, 0xe3, 0x39, 0xa3, + 0x66, 0x8c, 0x5b, 0xf5, 0x3b, 0x12, 0xbd, 0xc6, 0x10, 0xd7, 0x24, 0x70, 0x75, + 0x43, 0xe2, 0xab, 0x1f, 0xf3, 0x90, + ], + [ + 0x0c, 0x3a, 0xaa, 0x4f, 0x20, 0x7a, 0x15, 0x5f, 0x94, 0x54, 0x44, 0x77, 0x3c, + 0x2c, 0x65, 0x5a, 0xab, 0x09, 0x4b, 0xe8, 0xe5, 0xc9, 0x90, 0x3e, 0x9c, 0xe4, + 0x58, 0x7f, 0xc5, 0xfc, 0x17, 0x00, 0xad, 0xa8, 0x10, 0x68, 0xe5, 0x45, 0x4f, + 0xbd, 0x72, 0x86, 0x96, 0xd6, 0x24, 0x01, 0x80, 0x42, + ], + [ + 0x49, 0x11, 0x12, 0xa6, 0x41, 0xa5, 0x21, 0x01, 0x17, 0x99, 0x9f, 0x47, 0xd9, + 0xc8, 0x7c, 0xce, 0x7d, 0xbc, 0x51, 0x1c, 0x0b, 0xf1, 0x1b, 0xdb, 0xc2, 0xce, + 0x3f, 0x11, 0x21, 0x58, 0x9b, 0xd9, 0xab, 0x02, 0x22, 0x23, 0x8c, 0x17, 0xb9, + 0x00, 0x98, 0x75, 0xa3, 0xba, 0x2a, 0xa7, 0x05, 0x34, 0xe0, 0x62, 0x63, 0x16, + 0x77, 0x8c, 0xb9, 0x4e, 0x9c, 0x31, 0x01, 0x1f, 0xa2, 0x9c, 0xd5, 0x75, + ] + ), + test_case!( + [0x0e, 0x12, 0x78, 0xd0, 0x02, 0x30, 0x0d, 0x41, 0x07,], + [ + 0xd0, 0x60, 0x8e, 0x46, 0xde, 0xab, 0x56, 0x02, 0xf7, 0xaf, 0x62, 0x6d, 0xf7, + 0x37, 0x63, 0x87, 0xb1, 0x8c, 0x3c, 0xee, + ], + [ + 0xb6, 0xf5, 0x6f, 0x8f, 0x3e, 0xef, 0x67, 0x41, 0x19, 0x93, 0x2f, 0x94, 0xe4, + 0xc1, 0x34, 0x9d, 0xa3, 0x2e, 0x22, 0x43, 0x7c, 0x5d, 0x8d, 0x36, 0xe1, 0x30, + 0xba, 0x23, 0x56, 0xe4, 0x17, 0xf8, + ], + [ + 0x88, 0x1f, 0x55, 0x6b, 0xa1, 0xb7, 0x78, 0x57, 0x9c, 0x70, 0x20, 0x2a, 0x1c, + 0xb0, 0x7d, 0xfe, 0x50, 0x77, 0x5f, 0x1a, 0xef, 0x22, 0xa7, 0x19, 0xc7, 0xa4, + 0x20, 0xdb, 0x2a, 0x08, 0x5a, 0x19, 0x5d, 0x49, 0xd1, 0x7e, 0x62, 0x90, 0x3e, + 0x01, 0xd7, 0x8a, 0xb9, 0xc7, 0x78, 0x78, 0xac, 0xd3, + ], + [ + 0x67, 0x50, 0xb1, 0x79, 0xc9, 0x99, 0x8e, 0x3e, 0xad, 0x7c, 0xdd, 0x1e, 0xaa, + 0xcc, 0x2c, 0xa6, 0xc7, 0x6d, 0x1d, 0x6c, 0x46, 0xeb, 0x42, 0x33, 0xda, 0x2e, + 0x41, 0xde, 0xf9, 0xcd, 0xb2, 0x20, 0xce, 0x0a, 0x6d, 0x4a, 0x9e, 0x0d, 0x77, + 0x1f, 0xab, 0xd2, 0x9d, 0xbc, 0x26, 0xc9, 0xbe, 0x9a, 0xe6, 0x61, 0x0a, 0xcf, + 0xac, 0x1d, 0x66, 0x02, 0x0a, 0x23, 0x29, 0xcc, 0x98, 0xff, 0x4c, 0x8e, + ] + ), + test_case!( + [0x05, 0x59, 0x9d, 0x46, 0x81, 0xbe, 0xd2, 0xec, 0x44, 0xd7,], + [ + 0xfd, 0xe3, 0x78, 0xb4, 0x43, 0x36, 0xfa, 0xe4, 0xe2, 0x5e, 0x8f, 0x94, 0x72, + 0x6a, 0x6c, 0xe4, 0x01, 0x4f, 0x6e, 0x8a, + ], + [ + 0x02, 0xfc, 0x28, 0x37, 0x4f, 0xc9, 0x8a, 0xa2, 0xa4, 0x71, 0x8f, 0x6f, 0x8e, + 0x0b, 0xa2, 0xa6, 0x95, 0x2d, 0x5f, 0x13, 0x33, 0x95, 0x24, 0x87, 0xcb, 0xc7, + 0x7b, 0xbe, 0xde, 0xa9, 0xc0, 0xf2, + ], + [ + 0xeb, 0x42, 0x84, 0xeb, 0xc8, 0x15, 0x22, 0x7a, 0xaa, 0x0a, 0x4c, 0x0a, 0x12, + 0x54, 0x33, 0xea, 0xac, 0xfe, 0x53, 0x22, 0x1c, 0x5a, 0xdf, 0x60, 0x0e, 0x92, + 0x52, 0x25, 0xa7, 0x29, 0x0a, 0xcd, 0x0a, 0x88, 0x5e, 0xaa, 0xe0, 0x57, 0x94, + 0x2d, 0x66, 0xab, 0x27, 0x1f, 0x3e, 0xe1, 0xf2, 0xb2, + ], + [ + 0x84, 0xa8, 0x86, 0x2e, 0xf9, 0x2f, 0x67, 0xe9, 0x43, 0xad, 0xdb, 0xce, 0x99, + 0x79, 0x2a, 0xf8, 0xe1, 0xd7, 0x13, 0x3a, 0x34, 0x57, 0xd1, 0x14, 0x90, 0xab, + 0x0f, 0x8a, 0x5f, 0x1d, 0x42, 0x6e, 0x8e, 0x63, 0xa1, 0x6d, 0x06, 0x5c, 0x7e, + 0xec, 0x93, 0x3b, 0x09, 0x6b, 0x71, 0x7d, 0x83, 0x23, 0xfe, 0x31, 0x2f, 0x03, + 0xda, 0x38, 0xdb, 0xf1, 0xb8, 0x20, 0x5a, 0x28, 0xef, 0x10, 0x52, 0x25, + ] + ), + test_case!( + [0xe1, 0x93, 0x50, 0x85, 0xba, 0x11, 0x74, 0xcc, 0x82, 0x4c, 0x82,], + [ + 0x2b, 0xff, 0x1b, 0x64, 0x12, 0xb7, 0xdf, 0x5b, 0x9a, 0x95, 0x76, 0x53, 0xce, + 0x3f, 0x76, 0x41, 0xaa, 0x70, 0xaf, 0x2e, + ], + [ + 0xce, 0xce, 0x12, 0xbf, 0x23, 0xc7, 0x0c, 0xc1, 0xd1, 0xb6, 0xed, 0x13, 0x0d, + 0x29, 0x0e, 0x6f, 0x8e, 0x86, 0x25, 0xfe, 0x78, 0x50, 0x70, 0xbf, 0x21, 0x6a, + 0xf2, 0xfc, 0xf2, 0x4c, 0x1e, 0x66, + ], + [ + 0xc2, 0x88, 0x9a, 0x1e, 0x32, 0x4d, 0x0d, 0x1e, 0x29, 0xd9, 0x02, 0x58, 0x66, + 0x5c, 0x6e, 0xdf, 0x15, 0xb7, 0xcb, 0x6b, 0xda, 0x5a, 0x80, 0x34, 0xb2, 0xc2, + 0xa5, 0x17, 0x4a, 0xc6, 0x3b, 0x8a, 0x14, 0x48, 0x81, 0xa7, 0xc4, 0x80, 0x96, + 0xf7, 0xd4, 0x39, 0x81, 0x8f, 0x5e, 0xf2, 0x6f, 0x09, + ], + [ + 0xec, 0x33, 0xa6, 0x67, 0xed, 0x23, 0xd9, 0x62, 0x87, 0xda, 0x83, 0xce, 0x02, + 0x56, 0x39, 0xfb, 0x0d, 0x7e, 0x79, 0x4a, 0x73, 0x51, 0x4c, 0x18, 0x15, 0xe8, + 0x14, 0x44, 0xa0, 0x54, 0x3b, 0x41, 0x5f, 0xf2, 0x32, 0x4b, 0x18, 0x0d, 0x64, + 0x6f, 0xe1, 0xe9, 0x0b, 0x4c, 0x47, 0xf0, 0xfb, 0xbc, 0xa4, 0x93, 0x69, 0x9d, + 0xa9, 0x4f, 0x97, 0x7e, 0x9a, 0x7a, 0x33, 0xe1, 0xce, 0x31, 0x85, 0x22, + ] + ), + test_case!( + [0x0b, 0xeb, 0xfe, 0xb8, 0x0b, 0xc3, 0x81, 0x3c, 0xa0, 0xd1, 0xe5, 0x18,], + [ + 0x07, 0x10, 0xc0, 0x4f, 0x16, 0xe0, 0x09, 0x59, 0x8d, 0xe0, 0xd6, 0xf8, 0x11, + 0x84, 0x9a, 0x1b, 0xad, 0x4f, 0xc9, 0x7b, + ], + [ + 0xaa, 0x79, 0x98, 0x67, 0xe9, 0xcf, 0xaf, 0x0e, 0x16, 0xb1, 0x4d, 0xe5, 0x9e, + 0x28, 0x93, 0x50, 0x3a, 0x15, 0x50, 0x64, 0x73, 0x40, 0x1a, 0x19, 0xfd, 0x2b, + 0xfb, 0x12, 0x07, 0x52, 0xa5, 0x7f, + ], + [ + 0xa1, 0xe4, 0x82, 0x89, 0x8d, 0xa1, 0x8b, 0x44, 0x98, 0xa3, 0xf8, 0xab, 0x02, + 0x60, 0x28, 0x16, 0xd3, 0x32, 0x1b, 0xbd, 0xc4, 0xae, 0xc0, 0xd2, 0x90, 0xc6, + 0xa1, 0x12, 0xa1, 0xd2, 0x00, 0xac, 0x46, 0x42, 0xa2, 0x53, 0x5a, 0xb9, 0xf1, + 0x50, 0x80, 0x4c, 0xfa, 0xd7, 0xee, 0x36, 0xf9, 0x35, + ], + [ + 0x3f, 0x4c, 0x3e, 0x2b, 0x3c, 0x99, 0xc8, 0x23, 0x38, 0x7d, 0xbf, 0xb6, 0xaf, + 0xe3, 0x23, 0xf1, 0x95, 0x1b, 0xa4, 0x04, 0x9e, 0x44, 0xe1, 0x74, 0x0a, 0x38, + 0x71, 0x58, 0xfd, 0xe1, 0xb7, 0x59, 0x1f, 0x64, 0x5d, 0x77, 0xe2, 0x51, 0x11, + 0x3e, 0xcc, 0x80, 0x11, 0x60, 0xa8, 0x2f, 0xe9, 0x98, 0x24, 0x45, 0x90, 0x55, + 0x55, 0x24, 0xb9, 0x4f, 0x24, 0x23, 0xc8, 0xbc, 0xf2, 0x3b, 0x28, 0x8b, + ] + ), + test_case!( + [0x7c, 0x10, 0xa4, 0x4b, 0xde, 0x62, 0x86, 0xe0, 0x97, 0x96, 0x88, 0x5e, 0x8c,], + [ + 0xfa, 0xba, 0xd7, 0x84, 0xbf, 0x1b, 0x4c, 0xec, 0xaa, 0x27, 0x20, 0xa6, 0xda, + 0x43, 0xcb, 0x0b, 0x6d, 0xd1, 0xf6, 0xa9, + ], + [ + 0x34, 0xbe, 0x8f, 0xde, 0x2a, 0x43, 0x29, 0x0f, 0x67, 0x85, 0xce, 0xb6, 0x91, + 0x8a, 0xcf, 0x86, 0xe5, 0x77, 0x6d, 0x33, 0x6e, 0xc1, 0xfd, 0x04, 0x6a, 0x5b, + 0x3f, 0x6b, 0x17, 0x50, 0x6d, 0x4a, + ], + [ + 0xf4, 0x91, 0x8f, 0x35, 0x5d, 0xe9, 0x5a, 0xbc, 0xbc, 0xe8, 0x70, 0x00, 0xa1, + 0xbe, 0x36, 0x25, 0x13, 0x65, 0x31, 0xaa, 0xce, 0xe6, 0x73, 0xdf, 0x0f, 0xcc, + 0x29, 0x26, 0x6b, 0x92, 0x54, 0xa8, 0x20, 0x3c, 0xfa, 0x16, 0xfb, 0x3f, 0xda, + 0xde, 0x76, 0x1d, 0xcf, 0x44, 0x1d, 0xf2, 0xea, 0x61, + ], + [ + 0x19, 0x19, 0xb9, 0xd2, 0xf6, 0x26, 0xb7, 0x48, 0x7a, 0x06, 0x29, 0xfa, 0x70, + 0xef, 0xa6, 0x45, 0x5e, 0x75, 0x33, 0xa2, 0x5d, 0xda, 0x56, 0x7b, 0x76, 0xde, + 0x29, 0x2f, 0x78, 0x61, 0x8f, 0xcf, 0x21, 0x1e, 0x90, 0x83, 0x59, 0x93, 0x1d, + 0xe2, 0x1d, 0xe3, 0x11, 0x00, 0x01, 0x7f, 0x9e, 0x13, 0xa1, 0x82, 0xc5, 0xa6, + 0x03, 0xbf, 0xc1, 0x82, 0x33, 0x3a, 0x60, 0x47, 0xe0, 0xca, 0xea, 0x41, + ] + ), + test_case!( + [ + 0x08, 0x2f, 0x10, 0x32, 0x44, 0x7a, 0x54, 0x50, 0x09, 0x69, 0x4a, 0x29, 0x59, + 0x35, + ], + [ + 0x8f, 0x57, 0x27, 0xba, 0x85, 0xbf, 0x1c, 0xab, 0x25, 0x10, 0x54, 0x57, 0x6e, + 0x57, 0xbe, 0x9d, 0x36, 0x00, 0x1b, 0xd5, + ], + [ + 0x01, 0x8e, 0x47, 0xe3, 0xec, 0x99, 0x9b, 0xe9, 0xcc, 0xfa, 0xb5, 0xe2, 0x37, + 0x71, 0xeb, 0x01, 0xc8, 0x69, 0xc7, 0x70, 0xcd, 0x08, 0x39, 0x9e, 0x95, 0x65, + 0x61, 0x57, 0x20, 0x7c, 0x40, 0x5f, + ], + [ + 0x95, 0xbe, 0xc6, 0x2a, 0xd0, 0x90, 0x88, 0xfe, 0x7c, 0x12, 0x75, 0x17, 0x65, + 0x04, 0xd4, 0x70, 0x50, 0x69, 0xda, 0x81, 0x0d, 0x00, 0x26, 0x80, 0x6d, 0x12, + 0x7b, 0xb7, 0x5b, 0x44, 0x00, 0x0b, 0x17, 0xc3, 0xcc, 0x7d, 0x42, 0x01, 0xae, + 0xd3, 0xa1, 0xa7, 0x52, 0xae, 0xf6, 0x35, 0xf8, 0x4c, + ], + [ + 0x70, 0x28, 0x02, 0xf3, 0x9c, 0x2c, 0x0d, 0xb8, 0x04, 0x17, 0x6f, 0x20, 0x8c, + 0xb6, 0xa4, 0x69, 0xcf, 0x05, 0x80, 0x2d, 0x2e, 0xc7, 0x69, 0x94, 0xa7, 0x00, + 0xcf, 0xab, 0x42, 0x6f, 0x58, 0x2a, 0xec, 0x0c, 0x5e, 0x34, 0x50, 0x12, 0x68, + 0xdc, 0xbb, 0x30, 0x6b, 0x8a, 0xd8, 0x80, 0xfa, 0x15, 0x4e, 0x4b, 0x50, 0x5d, + 0xd2, 0x9c, 0x9b, 0x0e, 0xa7, 0xc8, 0x18, 0xe3, 0x1b, 0xf1, 0x2a, 0xfb, + ] + ), + test_case!( + [ + 0x47, 0x0b, 0xfa, 0x80, 0xbd, 0x30, 0x29, 0xa8, 0x70, 0x39, 0x8d, 0xe8, 0x99, + 0xd7, 0x63, + ], + [ + 0x35, 0x2c, 0x7f, 0xbf, 0xd0, 0x7a, 0xfa, 0xa7, 0xcb, 0x3a, 0xd2, 0x1d, 0xd7, + 0x34, 0x91, 0x5a, 0xb3, 0x7b, 0xbb, 0xb7, + ], + [ + 0x9d, 0x9c, 0xb4, 0x3b, 0x4d, 0xc9, 0x96, 0xa1, 0x54, 0x06, 0xbd, 0x3d, 0x36, + 0xde, 0x3b, 0x84, 0x12, 0x19, 0x8b, 0x91, 0xe7, 0xf0, 0xf4, 0x71, 0x28, 0xb3, + 0x88, 0x9f, 0x84, 0x1b, 0x0d, 0x11, + ], + [ + 0x06, 0x60, 0x85, 0x04, 0x64, 0x47, 0x81, 0x27, 0x39, 0x07, 0xbb, 0x46, 0xf0, + 0xb4, 0xab, 0x53, 0x36, 0x39, 0x4a, 0xc8, 0x9e, 0xe0, 0x47, 0x1c, 0xde, 0xb1, + 0x38, 0xb4, 0x00, 0xdc, 0x22, 0x17, 0xf1, 0x1c, 0x39, 0xab, 0x34, 0x5f, 0xf7, + 0xb5, 0xe6, 0x41, 0x3b, 0xcc, 0xcf, 0x5b, 0x3e, 0x2c, + ], + [ + 0xea, 0x58, 0x8e, 0x22, 0x55, 0xc4, 0x2b, 0xe7, 0x56, 0x4d, 0x84, 0x00, 0x41, + 0xe1, 0x8b, 0xe2, 0xf0, 0xce, 0x32, 0xdd, 0x8a, 0x31, 0x4a, 0x68, 0x5e, 0x2d, + 0xeb, 0xfb, 0x99, 0x58, 0x8a, 0xa0, 0x29, 0xde, 0xe8, 0x0f, 0x16, 0xe6, 0x85, + 0x44, 0xbc, 0xc4, 0x0a, 0x8b, 0x06, 0xb3, 0x5b, 0x6d, 0xa3, 0xff, 0xa5, 0x61, + 0x0e, 0x26, 0x63, 0x43, 0xb1, 0xfd, 0x59, 0xd1, 0x3b, 0x44, 0xce, 0xbc, + ] + ), + test_case!( + [ + 0x6b, 0xb7, 0xed, 0x62, 0x99, 0xab, 0x6b, 0xb3, 0x8c, 0xf4, 0xe1, 0x75, 0xc5, + 0x85, 0x46, 0xd3, + ], + [ + 0xdc, 0x20, 0xf5, 0x00, 0x86, 0x0d, 0x4e, 0x0e, 0x1f, 0xf5, 0x9e, 0x8a, 0xed, + 0x93, 0x6b, 0xbd, 0x17, 0x43, 0xe7, 0x90, + ], + [ + 0xea, 0xde, 0x1b, 0x2b, 0x62, 0xdf, 0x6d, 0xb4, 0x97, 0xbd, 0x1f, 0x08, 0xe6, + 0xbf, 0x0d, 0x76, 0x8c, 0xf1, 0x82, 0xff, 0x06, 0x0a, 0xb0, 0x03, 0xde, 0x73, + 0x4b, 0xac, 0xdf, 0x51, 0xa9, 0x19, + ], + [ + 0xfb, 0x9e, 0x54, 0x2f, 0xca, 0x0d, 0x0e, 0x8a, 0x8b, 0x1a, 0x8d, 0x49, 0x38, + 0xe0, 0xf3, 0x3a, 0xcd, 0xe3, 0x45, 0x69, 0x54, 0xf3, 0x53, 0x81, 0x0d, 0x30, + 0xed, 0xbd, 0x87, 0x72, 0x76, 0xba, 0xd2, 0x8e, 0x6d, 0x40, 0x08, 0x16, 0x55, + 0xca, 0x7e, 0xa8, 0x82, 0x52, 0x6f, 0x43, 0xa2, 0x7f, + ], + [ + 0x4a, 0xfc, 0xda, 0x87, 0x0d, 0x5c, 0x7b, 0xc8, 0x12, 0x07, 0x37, 0x46, 0x6f, + 0x41, 0x7f, 0xc0, 0xfb, 0xc3, 0xf9, 0x80, 0xe1, 0x0b, 0x08, 0x3b, 0x22, 0x02, + 0x10, 0x77, 0xe1, 0xb0, 0x4f, 0x93, 0xd5, 0x74, 0xd8, 0x87, 0x09, 0xf9, 0xa8, + 0xc6, 0xc3, 0x9b, 0x58, 0xd0, 0x3f, 0x86, 0x31, 0x39, 0x0e, 0xd4, 0x93, 0x9c, + 0xd8, 0xd0, 0x52, 0x7d, 0x9b, 0x8b, 0x1a, 0x03, 0x5e, 0x0e, 0x7f, 0xbe, + ] + ), + test_case!( + [ + 0x94, 0x34, 0xb7, 0x7f, 0x7c, 0x62, 0xed, 0x3a, 0x7a, 0x25, 0xe9, 0x6c, 0x3f, + 0x14, 0xd3, 0x54, 0x38, + ], + [ + 0x4d, 0x00, 0xf2, 0xad, 0x01, 0x19, 0x6b, 0xe3, 0xb1, 0x78, 0x7f, 0xf4, 0x3a, + 0x75, 0xf8, 0x81, 0xb5, 0x8e, 0x08, 0x64, + ], + [ + 0x12, 0x35, 0x6c, 0xe3, 0xea, 0xe2, 0xa1, 0xdd, 0x08, 0x57, 0xa8, 0x44, 0x16, + 0xcd, 0xf5, 0x92, 0xe8, 0xfa, 0xee, 0xbb, 0x8c, 0xa3, 0x7c, 0x44, 0x84, 0x01, + 0x02, 0x10, 0x49, 0x01, 0xd2, 0x7e, + ], + [ + 0x4d, 0xf6, 0xde, 0xc7, 0x48, 0x62, 0x4a, 0x16, 0x30, 0x37, 0x66, 0xc4, 0xd2, + 0x78, 0xf8, 0x00, 0x50, 0x3e, 0xf9, 0xed, 0x72, 0xdb, 0x54, 0x1b, 0x44, 0x92, + 0x75, 0xba, 0xa5, 0xfc, 0x6e, 0x7f, 0x5b, 0x58, 0x20, 0x46, 0x24, 0x26, 0x9a, + 0x70, 0xc2, 0x02, 0x6f, 0xb8, 0x0c, 0xb2, 0x60, 0xbc, + ], + [ + 0xd1, 0xd9, 0x7b, 0xe8, 0x57, 0xbf, 0xe5, 0x0b, 0x49, 0xa9, 0xad, 0x70, 0xf2, + 0x64, 0xf1, 0x30, 0x70, 0x1e, 0x90, 0x52, 0x29, 0xc7, 0x0f, 0x4c, 0x1c, 0x33, + 0xb8, 0x53, 0x2d, 0x87, 0x46, 0xe9, 0x75, 0x35, 0x92, 0x3d, 0xf3, 0x5c, 0xa4, + 0x57, 0x3f, 0x64, 0xed, 0xf6, 0x2a, 0x1e, 0x1d, 0x6f, 0x64, 0xd0, 0x8a, 0x70, + 0xf2, 0xce, 0x59, 0xd6, 0x15, 0x32, 0x02, 0x74, 0x2c, 0x21, 0x56, 0xba, + ] + ), + test_case!( + [ + 0xbb, 0x8d, 0x9c, 0x24, 0xa9, 0x07, 0x69, 0xbe, 0xc7, 0x08, 0x55, 0x22, 0x7e, + 0x3c, 0x09, 0xdd, 0x80, 0xce, + ], + [ + 0x11, 0x17, 0x92, 0xb5, 0x66, 0x86, 0xa4, 0x2a, 0xb8, 0x90, 0x20, 0x09, 0x3d, + 0x08, 0x5d, 0xbb, 0x3d, 0x46, 0xa5, 0x84, + ], + [ + 0x1f, 0xe8, 0x59, 0x35, 0x94, 0xc9, 0xf7, 0x24, 0xf8, 0xa4, 0xf1, 0xb0, 0xe1, + 0xd8, 0x38, 0x18, 0xa3, 0xfd, 0x3a, 0xc2, 0xfa, 0xa9, 0xc7, 0xa2, 0x8b, 0x8f, + 0x6d, 0x79, 0x26, 0xd0, 0x8a, 0x28, + ], + [ + 0x9d, 0xf7, 0x08, 0x13, 0x48, 0xe3, 0x82, 0xc7, 0xd3, 0x52, 0xf7, 0x07, 0xa9, + 0x83, 0xe9, 0xf7, 0xa2, 0xdd, 0x23, 0xbe, 0x38, 0x6f, 0x99, 0x4b, 0x50, 0x20, + 0x73, 0x65, 0x45, 0x10, 0x6e, 0xa6, 0x64, 0xbd, 0x48, 0x3d, 0x10, 0x59, 0x62, + 0x68, 0xcf, 0x0c, 0xee, 0x49, 0x2b, 0x1a, 0x62, 0x87, + ], + [ + 0x26, 0xca, 0x1b, 0x5b, 0xdc, 0x1a, 0xc3, 0xfc, 0xb5, 0x1c, 0x83, 0xbc, 0xfe, + 0xc4, 0x2e, 0xd2, 0xbb, 0x32, 0xc8, 0xc7, 0x09, 0x42, 0xf2, 0xf0, 0xe8, 0xd3, + 0x5c, 0xb5, 0xe5, 0x6d, 0xe3, 0x56, 0x1c, 0xf3, 0x8f, 0x94, 0x03, 0xaf, 0x20, + 0x60, 0xb6, 0xe1, 0xed, 0x49, 0xb8, 0x07, 0x16, 0x73, 0x2d, 0xd9, 0x19, 0x16, + 0x53, 0x4d, 0x4e, 0xc1, 0xb1, 0x91, 0xe4, 0xec, 0x60, 0x09, 0xfc, 0x80, + ] + ), + test_case!( + [ + 0xfa, 0x82, 0x9f, 0x49, 0x26, 0xce, 0x44, 0x75, 0x8f, 0x81, 0xb3, 0x37, 0x88, + 0xbd, 0x0b, 0x1b, 0xed, 0xe3, 0xcc, + ], + [ + 0x51, 0xfd, 0xe2, 0x78, 0x46, 0x97, 0xf3, 0xe1, 0x23, 0x2b, 0x6f, 0x83, 0x79, + 0x32, 0x7c, 0x09, 0x03, 0x8c, 0x32, 0x00, + ], + [ + 0x73, 0xd6, 0x8e, 0xa8, 0x5d, 0x14, 0xf7, 0x06, 0x2d, 0x80, 0xb9, 0xa5, 0x16, + 0x68, 0x26, 0x31, 0x45, 0x10, 0xa1, 0xfe, 0xc4, 0x98, 0xda, 0x05, 0x15, 0xae, + 0xd7, 0xcd, 0x9d, 0x4c, 0xe7, 0x2b, + ], + [ + 0xf4, 0x16, 0x61, 0x0c, 0xce, 0xfd, 0x2f, 0x7c, 0x5c, 0xd9, 0x00, 0x21, 0xe3, + 0x8e, 0x50, 0x81, 0x16, 0x62, 0x34, 0x5b, 0x6e, 0x84, 0x87, 0x29, 0x0b, 0x5f, + 0xf1, 0x6a, 0x08, 0x4f, 0x6e, 0xff, 0x45, 0xd5, 0x73, 0xdc, 0x38, 0xf3, 0x47, + 0x52, 0x44, 0x47, 0x0b, 0x49, 0x46, 0xb1, 0x5c, 0x5d, + ], + [ + 0x71, 0xb3, 0x7e, 0xd8, 0x8a, 0x54, 0xba, 0xd0, 0xda, 0xff, 0xb1, 0x5e, 0xb5, + 0xef, 0x6b, 0x5f, 0xd0, 0x23, 0xf0, 0xb9, 0xab, 0xb8, 0xeb, 0x2a, 0xd2, 0xea, + 0xd0, 0xed, 0x3f, 0xde, 0x2c, 0x2c, 0x7a, 0x32, 0x32, 0xe3, 0x5c, 0x30, 0x7c, + 0xd7, 0xaa, 0x1f, 0x45, 0xb9, 0xaf, 0xbe, 0x42, 0x53, 0x79, 0xac, 0xb6, 0xda, + 0x10, 0x06, 0x62, 0x3b, 0x69, 0xc1, 0xb2, 0x98, 0x96, 0x24, 0xc3, 0xda, + ] + ), + test_case!( + [ + 0x04, 0x9a, 0x7c, 0x85, 0x56, 0xb5, 0x4d, 0x57, 0xf2, 0x72, 0x30, 0xa8, 0x88, + 0x1f, 0xa7, 0x71, 0x66, 0xe8, 0x36, 0xd0, + ], + [ + 0xb7, 0x7b, 0xbe, 0x98, 0xe8, 0x29, 0x8b, 0xda, 0xb3, 0x89, 0x78, 0x6f, 0xdf, + 0xf0, 0x5a, 0xf4, 0x45, 0x8f, 0x33, 0x9a, + ], + [ + 0xf6, 0xfd, 0x72, 0xb8, 0x43, 0x14, 0xe0, 0xf6, 0xb2, 0x41, 0x5b, 0x3b, 0x26, + 0x69, 0xa6, 0x97, 0x06, 0xd7, 0x81, 0x79, 0x9b, 0xe0, 0x94, 0xb5, 0x39, 0xde, + 0x6b, 0x41, 0xbc, 0xc6, 0xe2, 0x18, + ], + [ + 0xb9, 0x6e, 0xfd, 0x82, 0xec, 0x46, 0x8b, 0xb4, 0xa0, 0x6f, 0xc3, 0x41, 0x29, + 0x84, 0x19, 0x79, 0xd5, 0x64, 0xcc, 0x76, 0x51, 0x0f, 0xbf, 0x9a, 0x65, 0x1d, + 0x4c, 0x8f, 0x81, 0xd8, 0xf2, 0x2d, 0x24, 0x57, 0x22, 0x94, 0xef, 0x5f, 0x71, + 0x99, 0x46, 0xf2, 0x57, 0x83, 0x5b, 0xf4, 0x72, 0x0e, + ], + [ + 0x01, 0x3a, 0x64, 0x78, 0xbb, 0x6f, 0x05, 0xbc, 0x0e, 0x70, 0x70, 0x10, 0x13, + 0xc8, 0xa2, 0x7d, 0xcf, 0xd4, 0xa7, 0x3f, 0xaf, 0x14, 0xab, 0x61, 0x63, 0x03, + 0x4b, 0xd0, 0xed, 0xbb, 0x73, 0x59, 0x43, 0xaf, 0x2f, 0xa7, 0x45, 0x10, 0xfe, + 0x62, 0x10, 0xa4, 0x02, 0xd5, 0x0e, 0x1a, 0x85, 0x61, 0xca, 0xaa, 0xd4, 0xd4, + 0xa9, 0x93, 0x91, 0xe2, 0x54, 0x6d, 0x3c, 0x1b, 0x8b, 0xa0, 0x4d, 0x88, + ] + ), + test_case!( + [ + 0x2b, 0x7f, 0x18, 0x78, 0xc0, 0x08, 0x39, 0x2c, 0x83, 0x9e, 0x57, 0xb6, 0x5a, + 0xd4, 0x69, 0x13, 0xfa, 0xfe, 0x51, 0xfd, 0xa8, + ], + [ + 0xc5, 0xa1, 0xb1, 0x21, 0x81, 0xac, 0xa2, 0x29, 0x85, 0x8a, 0x00, 0x8f, 0xf0, + 0x35, 0x1d, 0xca, 0x9e, 0x27, 0x62, 0x04, + ], + [ + 0xe0, 0xfe, 0x5e, 0x18, 0xc5, 0x21, 0x79, 0x4b, 0xae, 0x79, 0x7d, 0x29, 0x71, + 0xe6, 0xfb, 0x14, 0xb5, 0xe1, 0x6f, 0xa2, 0xc3, 0xa3, 0x07, 0x66, 0x32, 0xad, + 0x76, 0x23, 0x24, 0xbe, 0x1b, 0xb6, + ], + [ + 0xc1, 0x4b, 0x60, 0x9c, 0x52, 0x4e, 0x4d, 0xa3, 0xe4, 0x4d, 0x74, 0x1f, 0xee, + 0xc7, 0xa0, 0x5b, 0xa7, 0xdc, 0x79, 0x90, 0x41, 0x48, 0x4e, 0xe8, 0x7f, 0xeb, + 0x53, 0x28, 0x27, 0xd0, 0x59, 0x96, 0xc1, 0x3f, 0xd6, 0xac, 0x1e, 0x23, 0x51, + 0xc0, 0x8b, 0x6e, 0xdb, 0x76, 0xea, 0xdd, 0x9f, 0xfa, + ], + [ + 0xf0, 0x42, 0x10, 0x13, 0x4d, 0x66, 0xbc, 0x3f, 0x1c, 0x0b, 0xfc, 0x57, 0x8f, + 0x75, 0x7c, 0x6b, 0xad, 0xd4, 0xae, 0x65, 0xf7, 0x17, 0x31, 0xf9, 0xdc, 0x62, + 0xe3, 0x26, 0xef, 0x60, 0x1a, 0x06, 0x6f, 0xe2, 0xa1, 0x9f, 0x61, 0xd8, 0x70, + 0xfe, 0x50, 0x4d, 0x02, 0x32, 0xea, 0xfc, 0x9c, 0x0c, 0x7f, 0x87, 0x4a, 0x77, + 0xcd, 0x70, 0xa4, 0x28, 0x67, 0x2e, 0x3e, 0xaf, 0x30, 0x3d, 0x58, 0x11, + ] + ), + test_case!( + [ + 0x1a, 0xc9, 0x93, 0x29, 0xa1, 0x42, 0xb5, 0x17, 0xd2, 0xa3, 0xa2, 0x06, 0xf6, + 0x19, 0xdb, 0xea, 0x52, 0x05, 0xd8, 0x3c, 0x60, 0xdb, + ], + [ + 0xce, 0xca, 0xaa, 0xff, 0xe6, 0x55, 0xa2, 0xfb, 0xb3, 0x4f, 0xf4, 0x2a, 0xef, + 0x27, 0xf3, 0x63, 0x57, 0x46, 0x4e, 0xac, + ], + [ + 0x12, 0x1f, 0x90, 0x95, 0xe8, 0xdb, 0x52, 0x4a, 0x66, 0xe2, 0x9d, 0xe9, 0x03, + 0xc3, 0x33, 0x15, 0x7a, 0x63, 0x54, 0x70, 0x9e, 0x0a, 0x18, 0x1c, 0x61, 0x00, + 0x36, 0xd5, 0xb0, 0x9a, 0xbe, 0xef, + ], + [ + 0x44, 0x82, 0xd1, 0xd3, 0x7a, 0xd7, 0xf0, 0xff, 0x34, 0xcb, 0x20, 0xb7, 0x51, + 0x5f, 0x52, 0xf5, 0xd8, 0xb1, 0x2b, 0xae, 0xc4, 0x28, 0x3d, 0x2d, 0xa3, 0x7b, + 0x0c, 0x91, 0x14, 0x41, 0x62, 0x16, 0x02, 0x02, 0x58, 0x4e, 0x64, 0xea, 0xce, + 0x99, 0x14, 0xe8, 0x6a, 0x66, 0x24, 0x68, 0x78, 0xf5, + ], + [ + 0x3a, 0x39, 0x8a, 0x5e, 0xdd, 0x27, 0xca, 0xda, 0x88, 0x19, 0x6e, 0xae, 0xb3, + 0x7d, 0x11, 0x27, 0x3e, 0xa2, 0x1b, 0x13, 0x56, 0x69, 0x09, 0x7a, 0x77, 0x01, + 0xf5, 0xb7, 0x4d, 0xfa, 0x79, 0xb6, 0xfa, 0x77, 0x00, 0x15, 0x8f, 0x2c, 0xaf, + 0xd8, 0xee, 0x91, 0xed, 0xd5, 0x54, 0x7d, 0x71, 0x22, 0xe9, 0x23, 0x84, 0x22, + 0x0c, 0xc0, 0xca, 0xcd, 0xf7, 0x9e, 0xc1, 0xeb, 0xdd, 0xf9, 0xfe, 0xcf, + ] + ), + test_case!( + [ + 0xde, 0x2b, 0x68, 0x04, 0xee, 0xb5, 0x4e, 0xd0, 0xca, 0x2f, 0x2c, 0x6a, 0x88, + 0x75, 0x67, 0xb4, 0x7a, 0x17, 0x72, 0xf3, 0xcf, 0x0d, 0x51, + ], + [ + 0x3e, 0x2f, 0x15, 0x9d, 0x6a, 0x62, 0x11, 0x5f, 0x09, 0x38, 0x1a, 0x0c, 0x5e, + 0x61, 0xac, 0xac, 0x48, 0xeb, 0x65, 0x0c, + ], + [ + 0xde, 0x73, 0x4e, 0xd5, 0x73, 0xe0, 0x9a, 0x51, 0x52, 0x68, 0x9b, 0x25, 0x20, + 0x05, 0x48, 0x68, 0xb6, 0xb1, 0x38, 0x7f, 0x51, 0x0b, 0x01, 0x2b, 0x1e, 0x69, + 0x42, 0x3e, 0x95, 0x4c, 0x69, 0x20, + ], + [ + 0xd2, 0x28, 0x8b, 0x91, 0x5c, 0x87, 0xe5, 0xb3, 0xc2, 0x4b, 0x4b, 0x87, 0x0f, + 0x5a, 0x97, 0xbf, 0xbb, 0xee, 0xd0, 0x23, 0x2c, 0x19, 0x79, 0x88, 0x96, 0x18, + 0x02, 0x55, 0x21, 0x45, 0x73, 0x5f, 0x07, 0xe6, 0x21, 0xcb, 0xb3, 0x1e, 0xd2, + 0x88, 0x5d, 0xc2, 0x3c, 0x5a, 0x0d, 0xe7, 0x43, 0x4a, + ], + [ + 0x04, 0x86, 0x15, 0x1d, 0x60, 0x85, 0xab, 0x87, 0x43, 0x83, 0x14, 0xcb, 0xde, + 0xe7, 0x69, 0xe5, 0x3a, 0x26, 0xeb, 0xd6, 0x9e, 0x29, 0x97, 0x79, 0xda, 0x38, + 0xa5, 0x02, 0xd3, 0xa2, 0x99, 0x66, 0xc0, 0x35, 0x62, 0xd7, 0xbd, 0x17, 0xf5, + 0xf0, 0x65, 0xeb, 0x7b, 0x3a, 0x74, 0x8d, 0x4e, 0xf7, 0xf1, 0xe1, 0x38, 0x4b, + 0xe5, 0x1f, 0x56, 0x20, 0x12, 0x89, 0xca, 0xb7, 0xc6, 0x6a, 0x4b, 0xdd, + ] + ), + test_case!( + [ + 0xc3, 0xe8, 0x8b, 0x6d, 0x2e, 0x27, 0x45, 0x26, 0x68, 0xa8, 0xe5, 0x0f, 0x22, + 0xcd, 0xbd, 0xef, 0xc8, 0x00, 0x0e, 0x5d, 0x76, 0xdc, 0x1d, 0x2e, + ], + [ + 0xd2, 0xd9, 0x86, 0x45, 0xf8, 0x63, 0xe8, 0x78, 0xaa, 0x4f, 0xf2, 0x62, 0x30, + 0x4f, 0xe3, 0xb5, 0xb8, 0xc4, 0xb4, 0xd6, + ], + [ + 0x74, 0x86, 0x51, 0x31, 0xfd, 0x56, 0xff, 0x91, 0x3e, 0x71, 0xaa, 0x75, 0x2d, + 0xe4, 0x68, 0xed, 0x7b, 0x62, 0xbf, 0xc2, 0x02, 0x97, 0x17, 0xc5, 0xdc, 0x21, + 0xe6, 0x91, 0x4e, 0x71, 0xd5, 0xd9, + ], + [ + 0x23, 0x2f, 0x22, 0x48, 0x72, 0xf2, 0xe3, 0x2f, 0xfd, 0x48, 0x9b, 0x06, 0xc7, + 0x14, 0xcd, 0xc6, 0x78, 0x7e, 0x3a, 0x6e, 0x85, 0xb5, 0xa3, 0xc6, 0x0e, 0x45, + 0x56, 0x42, 0xe4, 0xea, 0x1c, 0x0d, 0xa9, 0x62, 0xca, 0xe8, 0xb8, 0xe9, 0x01, + 0x33, 0x70, 0xd5, 0xfe, 0x90, 0x38, 0x6f, 0x9b, 0x7b, + ], + [ + 0x07, 0x26, 0x97, 0x53, 0xaf, 0x2e, 0xa9, 0x16, 0xa0, 0xbf, 0xcd, 0x43, 0xe4, + 0x21, 0xe0, 0x7d, 0x10, 0xde, 0x71, 0xb2, 0x74, 0xf0, 0x91, 0x57, 0x3a, 0xe9, + 0x1a, 0x1f, 0xdf, 0x8c, 0x83, 0xb2, 0xed, 0xa0, 0x79, 0xcc, 0xcc, 0x31, 0x5b, + 0x78, 0xfa, 0x69, 0xc2, 0x5d, 0xd0, 0x0c, 0x9f, 0x1e, 0x75, 0x6f, 0x08, 0x86, + 0x06, 0x1e, 0xee, 0x95, 0x0c, 0xe5, 0x56, 0x2e, 0xe6, 0xad, 0x70, 0xe9, + ] + ), + test_case!( + [ + 0x23, 0xbb, 0x9b, 0x96, 0x20, 0xd0, 0x03, 0xdd, 0xba, 0x97, 0x99, 0x75, 0xcd, + 0x8a, 0x71, 0x53, 0x03, 0x03, 0xd7, 0x55, 0xec, 0x93, 0xd1, 0xed, 0xf5, + ], + [ + 0xbd, 0xc8, 0x6d, 0x60, 0xb5, 0xfb, 0x1c, 0xc4, 0x07, 0xbe, 0x68, 0x97, 0x51, + 0x1a, 0x2f, 0xe1, 0xd9, 0x57, 0x0c, 0xf2, + ], + [ + 0xc8, 0xcd, 0xf7, 0xfa, 0xdd, 0x6e, 0x85, 0x9d, 0xd0, 0x39, 0x74, 0x3e, 0x4c, + 0xba, 0x12, 0xe7, 0x7b, 0x90, 0x81, 0xf3, 0xf3, 0x03, 0xb7, 0x37, 0x90, 0x28, + 0xa3, 0x6d, 0x8f, 0x57, 0xe1, 0x4b, + ], + [ + 0x15, 0x25, 0x48, 0x5e, 0x54, 0xe3, 0x35, 0xbc, 0x5f, 0x44, 0xf5, 0xa9, 0x09, + 0x75, 0xc1, 0xca, 0xfb, 0x30, 0x64, 0x19, 0x53, 0xfa, 0x90, 0x95, 0xad, 0xd3, + 0xf4, 0xe0, 0x5e, 0x36, 0x12, 0x38, 0xd2, 0x26, 0x30, 0x90, 0xd7, 0xe3, 0x62, + 0x21, 0xc9, 0xd2, 0x3b, 0xa1, 0x9c, 0xaa, 0x84, 0x4e, + ], + [ + 0x7a, 0xde, 0x43, 0xe8, 0x4c, 0x39, 0x7c, 0xa9, 0x22, 0x0f, 0x61, 0x2b, 0x93, + 0xa8, 0x81, 0x9f, 0x01, 0x24, 0x7d, 0x16, 0x6f, 0xf1, 0x24, 0x7d, 0x07, 0x85, + 0x99, 0x79, 0x66, 0x44, 0x6b, 0x94, 0xfe, 0x02, 0x14, 0x3c, 0x1f, 0xa3, 0xe2, + 0xf4, 0x05, 0x06, 0x24, 0x91, 0x1f, 0xf0, 0x8e, 0x88, 0xbb, 0xd9, 0x2a, 0x5c, + 0x69, 0x77, 0x1b, 0x66, 0xc5, 0x81, 0x4e, 0xb9, 0x1d, 0xe0, 0x92, 0xba, + ] + ), + test_case!( + [ + 0xa6, 0x81, 0x05, 0xec, 0x7a, 0x50, 0xe6, 0xa5, 0x20, 0x76, 0xb1, 0x03, 0x13, + 0x33, 0x5a, 0xe1, 0x63, 0xf3, 0xc9, 0x65, 0x45, 0x2b, 0x5f, 0x69, 0xa3, 0xf3, + ], + [ + 0x4c, 0xe4, 0xd1, 0x65, 0xb1, 0xfc, 0x1f, 0x52, 0x62, 0xe6, 0xad, 0xf6, 0x2b, + 0xdf, 0x99, 0xa6, 0xdc, 0x2d, 0x21, 0xa0, + ], + [ + 0xcd, 0x86, 0x39, 0x09, 0x7a, 0xeb, 0x72, 0x76, 0x3a, 0x65, 0xdf, 0xd6, 0xa6, + 0x52, 0x84, 0x1a, 0xdc, 0xae, 0x19, 0x0c, 0x3f, 0xfd, 0xfe, 0x6c, 0xd0, 0x06, + 0x0e, 0x59, 0xb5, 0x74, 0x5b, 0x48, + ], + [ + 0x01, 0xd2, 0xf0, 0x74, 0xf1, 0x5c, 0xf4, 0xa9, 0xda, 0x4a, 0xb2, 0xa2, 0xd3, + 0x3f, 0xdc, 0xb0, 0xe2, 0xc9, 0x79, 0xfc, 0xb0, 0x4d, 0x9d, 0x3d, 0xa2, 0x26, + 0xe7, 0xec, 0x32, 0x5b, 0x6a, 0x30, 0xf7, 0xd7, 0xda, 0xc4, 0xe4, 0x19, 0x3a, + 0x88, 0x18, 0x7a, 0x13, 0x4a, 0x15, 0x74, 0x90, 0xd4, + ], + [ + 0x5d, 0x66, 0xfe, 0x48, 0x23, 0x96, 0x2d, 0x0e, 0x37, 0x43, 0xe3, 0x35, 0x35, + 0x33, 0x7a, 0x48, 0xbb, 0x12, 0x5c, 0x2f, 0x95, 0x9b, 0xf5, 0xa9, 0xf1, 0x64, + 0x84, 0x20, 0x86, 0xa3, 0x5b, 0x32, 0x18, 0x01, 0x0c, 0x8d, 0xfa, 0xbc, 0xd2, + 0x85, 0x67, 0x8a, 0xd7, 0xaf, 0x79, 0xab, 0xb0, 0x21, 0x10, 0x1b, 0x64, 0xb8, + 0xf4, 0xb2, 0x84, 0xf2, 0x11, 0xc3, 0xc0, 0x03, 0x75, 0x72, 0x4a, 0xf2, + ] + ), + test_case!( + [ + 0x90, 0xd3, 0x1b, 0xfa, 0x1f, 0x19, 0xb6, 0x8b, 0x66, 0xc3, 0x3e, 0x86, 0x34, + 0x27, 0x02, 0x8b, 0x2e, 0x39, 0xb0, 0x3c, 0xab, 0xdd, 0x27, 0xc5, 0x89, 0x84, + 0xc5, + ], + [ + 0x93, 0x6d, 0x2e, 0x14, 0xee, 0x14, 0x4f, 0x5e, 0xdb, 0xbc, 0xc8, 0x65, 0x33, + 0xa9, 0x24, 0x6a, 0x73, 0xa7, 0x52, 0x31, + ], + [ + 0xcc, 0x4f, 0xd9, 0xb6, 0x04, 0xcc, 0xd7, 0x1b, 0xc9, 0xba, 0x5a, 0xf9, 0x97, + 0x0f, 0x87, 0x20, 0x64, 0xe3, 0xed, 0x02, 0xa6, 0x65, 0xb2, 0x90, 0x43, 0x62, + 0xd1, 0x56, 0xa4, 0xe3, 0x25, 0x62, + ], + [ + 0x13, 0xe3, 0xee, 0x68, 0x88, 0xa7, 0x91, 0xa7, 0xfd, 0x37, 0x6f, 0xdb, 0xac, + 0x6c, 0x65, 0xaf, 0x29, 0x77, 0xc8, 0x29, 0x6b, 0xf4, 0x20, 0xee, 0x0c, 0x51, + 0x2b, 0x6f, 0x10, 0xfc, 0x18, 0x5a, 0x77, 0x8b, 0xcc, 0x22, 0xbc, 0x40, 0x89, + 0x89, 0x05, 0x22, 0x4e, 0xfd, 0x3b, 0x03, 0x0b, 0x0d, + ], + [ + 0x99, 0xac, 0x48, 0x23, 0xa4, 0xeb, 0x91, 0xf0, 0x5a, 0x55, 0x59, 0x91, 0x99, + 0xfc, 0x12, 0xcd, 0xe0, 0xb0, 0x98, 0x36, 0xad, 0x20, 0x28, 0x91, 0x0b, 0x13, + 0x18, 0x34, 0xa0, 0xe9, 0x28, 0xf8, 0x8a, 0xea, 0x7e, 0xbf, 0xe6, 0xea, 0x0a, + 0x16, 0xc6, 0xe1, 0x4a, 0xfa, 0x31, 0x00, 0x8f, 0xb8, 0x50, 0x81, 0x1b, 0xfa, + 0x7a, 0x9a, 0xaf, 0x10, 0x82, 0xfe, 0x2d, 0x84, 0xb4, 0x43, 0xac, 0x6c, + ] + ), + test_case!( + [ + 0x20, 0x2f, 0xaf, 0x9a, 0x58, 0x7b, 0x45, 0xf0, 0x8b, 0xab, 0xe6, 0x9a, 0x9a, + 0xe8, 0xfe, 0xcc, 0x8d, 0xe7, 0xf6, 0xe5, 0x43, 0xc7, 0xef, 0xe2, 0x86, 0x0d, + 0x45, 0x0a, + ], + [ + 0x85, 0xd9, 0xed, 0x98, 0x63, 0x2c, 0xcd, 0x79, 0x16, 0xc5, 0xa4, 0x7e, 0xb7, + 0x86, 0x37, 0x44, 0xc2, 0x41, 0xfc, 0xba, + ], + [ + 0x18, 0x9e, 0x9a, 0x1a, 0xa8, 0x85, 0xfa, 0x04, 0xae, 0x0a, 0x92, 0x4f, 0xf9, + 0xfa, 0x56, 0xda, 0x74, 0x86, 0xa0, 0x61, 0x6a, 0x5f, 0x64, 0x73, 0x97, 0x27, + 0x1a, 0x24, 0xbb, 0xd9, 0x53, 0x29, + ], + [ + 0x20, 0x6d, 0xaa, 0x85, 0xcb, 0xd3, 0x98, 0x25, 0xdb, 0xd2, 0x3b, 0xff, 0xbf, + 0xce, 0x2e, 0xce, 0x74, 0xf7, 0x4d, 0xdb, 0xfc, 0x4a, 0x7d, 0x1a, 0xd8, 0x56, + 0xc0, 0xe0, 0x58, 0x90, 0x61, 0x9d, 0x62, 0x72, 0x08, 0xab, 0x57, 0x3d, 0xef, + 0xab, 0xf6, 0x86, 0x59, 0xf0, 0xe7, 0xec, 0xe4, 0x0a, + ], + [ + 0x23, 0x50, 0x5d, 0xd0, 0x52, 0xd7, 0xd8, 0xea, 0x72, 0xec, 0xe0, 0x81, 0xc0, + 0xba, 0x48, 0xdf, 0xe6, 0xdc, 0x3c, 0xf6, 0xb5, 0x46, 0x95, 0x8f, 0x06, 0xa4, + 0x2e, 0x17, 0x67, 0x1a, 0x12, 0x2a, 0xdd, 0xbc, 0xf2, 0x81, 0xf4, 0x72, 0xa5, + 0x24, 0x0e, 0xb6, 0x2d, 0x57, 0x9f, 0xdc, 0xcc, 0xd6, 0xa0, 0xd6, 0xe4, 0x94, + 0xbe, 0x4e, 0x85, 0xf3, 0xac, 0x7f, 0xfd, 0xfe, 0x3e, 0xf7, 0x83, 0x9d, + ] + ), + test_case!( + [ + 0xe2, 0xaf, 0x9b, 0x6b, 0x3c, 0x12, 0x91, 0x6c, 0xd5, 0x1a, 0xd1, 0xa7, 0x0b, + 0x36, 0x4a, 0x56, 0x70, 0x90, 0xee, 0xa9, 0xaa, 0x5a, 0xf2, 0x45, 0x62, 0x03, + 0x1c, 0x46, 0x10, + ], + [ + 0xa2, 0xce, 0xfe, 0x9b, 0xe9, 0x4e, 0x41, 0xaa, 0x20, 0xe9, 0xd7, 0x70, 0x0f, + 0x9d, 0xe8, 0x7e, 0x35, 0xff, 0x30, 0x44, + ], + [ + 0xb6, 0xc1, 0xea, 0x92, 0x66, 0x58, 0x97, 0xe0, 0x05, 0x08, 0x46, 0x3d, 0xcc, + 0xf6, 0xd8, 0x63, 0x69, 0x63, 0x09, 0xf1, 0x0a, 0x13, 0xdc, 0x53, 0x79, 0xdf, + 0xa4, 0x72, 0x3e, 0xc3, 0x69, 0xb0, + ], + [ + 0x6e, 0x93, 0xe2, 0xd7, 0x75, 0x83, 0xdc, 0x1d, 0xe9, 0x77, 0x44, 0xd4, 0xa1, + 0x89, 0x83, 0x00, 0xe8, 0xee, 0xca, 0x9f, 0x96, 0x97, 0x9f, 0x2f, 0x9e, 0x9c, + 0xc3, 0x4f, 0x42, 0x6f, 0x3e, 0x24, 0xc4, 0x13, 0x91, 0x6a, 0x47, 0xb2, 0x76, + 0x09, 0x57, 0xf3, 0x49, 0x5a, 0xdc, 0xd0, 0x4d, 0x32, + ], + [ + 0xb8, 0xa8, 0x36, 0xac, 0xa9, 0xda, 0xd7, 0x9c, 0x51, 0x73, 0x5d, 0x68, 0xf0, + 0x35, 0xb1, 0x56, 0xe2, 0x39, 0xab, 0xa5, 0x34, 0x25, 0x58, 0xff, 0x6b, 0x15, + 0x54, 0x19, 0x9d, 0xf8, 0x2d, 0xbe, 0x19, 0x0a, 0x20, 0x65, 0xc0, 0x8c, 0x88, + 0xa2, 0x0a, 0xd6, 0xa0, 0xe4, 0x68, 0x63, 0x0b, 0xd4, 0x97, 0x52, 0x1a, 0xab, + 0x37, 0x53, 0x12, 0xa5, 0xc3, 0xb6, 0x5c, 0xf2, 0x4d, 0x8b, 0x28, 0x81, + ] + ), + test_case!( + [ + 0x6e, 0xfa, 0x7b, 0x4a, 0x1c, 0x28, 0x36, 0x70, 0x73, 0x82, 0x19, 0xb7, 0xca, + 0xd0, 0xaf, 0x7a, 0x2b, 0xc1, 0x65, 0x56, 0x07, 0x84, 0xd2, 0x78, 0xa7, 0xc7, + 0x19, 0x9d, 0x5d, 0xc2, + ], + [ + 0xf7, 0x6d, 0xc0, 0xd0, 0x81, 0xf3, 0xe2, 0x66, 0xda, 0xff, 0xa8, 0x5d, 0xd6, + 0x11, 0x50, 0xf1, 0x9e, 0xc4, 0x6f, 0x73, + ], + [ + 0xbd, 0x13, 0x3f, 0x21, 0xdc, 0x8f, 0x72, 0x5f, 0xc1, 0x9a, 0x6d, 0x49, 0x68, + 0xd5, 0x86, 0x63, 0xce, 0xf6, 0xad, 0x1d, 0xca, 0x92, 0x67, 0xf2, 0xb2, 0xad, + 0x48, 0x85, 0x92, 0x71, 0x0e, 0xa9, + ], + [ + 0xdd, 0x77, 0xdf, 0xdc, 0x09, 0xca, 0x11, 0x9a, 0x71, 0x9b, 0x1a, 0xf0, 0xa6, + 0x0d, 0x12, 0xd5, 0x0d, 0x30, 0xd5, 0x97, 0x4e, 0xe4, 0xf2, 0x47, 0xad, 0xe1, + 0xa2, 0x3e, 0x3b, 0x87, 0x0a, 0xb5, 0xcb, 0x77, 0x5d, 0xea, 0xc4, 0x24, 0xbe, + 0xdb, 0xe5, 0x61, 0x5d, 0xad, 0x5d, 0xe7, 0x2a, 0x7e, + ], + [ + 0x33, 0x40, 0xab, 0xc2, 0x47, 0xe2, 0xf1, 0xb1, 0x72, 0xfc, 0x8f, 0x21, 0xe7, + 0x9c, 0x38, 0x47, 0xa6, 0xd8, 0xc9, 0x63, 0x68, 0xe7, 0x82, 0x42, 0xeb, 0xfa, + 0xdb, 0x11, 0x40, 0x30, 0x94, 0xd9, 0x80, 0xe0, 0x8a, 0x6f, 0x2a, 0xe2, 0xdb, + 0x9c, 0x6f, 0xc2, 0xe5, 0x5f, 0x9f, 0x65, 0x39, 0x84, 0xe5, 0xd2, 0x9b, 0x9b, + 0x55, 0xa7, 0x1f, 0xca, 0xb4, 0x07, 0xc3, 0xe3, 0x6c, 0x33, 0xfb, 0xe7, + ] + ), + test_case!( + [ + 0xb1, 0x17, 0x7b, 0x96, 0x47, 0x7a, 0xf0, 0x55, 0x34, 0x29, 0x6c, 0x56, 0x85, + 0xea, 0xf6, 0x6a, 0x88, 0x25, 0x3a, 0xdb, 0x89, 0x15, 0x5b, 0x52, 0x4a, 0x82, + 0x2c, 0x0a, 0xc6, 0x7b, 0xb6, + ], + [ + 0x92, 0x25, 0xcb, 0x49, 0x05, 0xef, 0x9d, 0x4e, 0x69, 0xa5, 0xd0, 0x10, 0x4e, + 0x14, 0x2a, 0x2d, 0x94, 0x8e, 0x45, 0xb9, + ], + [ + 0xe4, 0xf1, 0x9f, 0xc0, 0x5e, 0x0d, 0xb2, 0x3e, 0x43, 0xc5, 0xbb, 0xfb, 0x83, + 0xf5, 0xa0, 0x92, 0xdc, 0xee, 0x23, 0xde, 0x5e, 0xe5, 0xd0, 0x42, 0x21, 0xc4, + 0x76, 0x59, 0x97, 0x4d, 0x9d, 0xcd, + ], + [ + 0xb3, 0x8f, 0xc1, 0x95, 0xed, 0x3a, 0x19, 0xf1, 0x77, 0xbe, 0x5c, 0x97, 0xc4, + 0x23, 0x88, 0xef, 0x6c, 0x66, 0xdb, 0xa0, 0xb2, 0x46, 0x72, 0x48, 0x33, 0x01, + 0x15, 0x44, 0x4c, 0x74, 0x7c, 0x39, 0x37, 0x73, 0xdc, 0x27, 0xf2, 0x2d, 0xda, + 0x32, 0x8d, 0x81, 0x86, 0x22, 0xa5, 0xda, 0xab, 0x75, + ], + [ + 0xe5, 0x89, 0x07, 0x2a, 0x25, 0xcb, 0xab, 0x14, 0xfe, 0xba, 0xed, 0x44, 0x28, + 0xd9, 0x59, 0x3a, 0xac, 0x07, 0xf9, 0x7d, 0x51, 0x34, 0xdf, 0xe5, 0x30, 0x1e, + 0xeb, 0x77, 0xee, 0xb0, 0xe4, 0xca, 0x72, 0xb6, 0xd9, 0x1e, 0x43, 0x6f, 0x27, + 0x5b, 0xb8, 0x39, 0x18, 0x17, 0xa1, 0x1e, 0x56, 0x65, 0x59, 0xa7, 0x5e, 0xbc, + 0x19, 0xe0, 0x90, 0x51, 0xe5, 0x6f, 0x05, 0xd2, 0xdf, 0x07, 0x4f, 0xf0, + ] + ), + test_case!( + [ + 0x41, 0x9a, 0x9f, 0x71, 0x32, 0x26, 0x56, 0x43, 0x50, 0x5b, 0x95, 0xed, 0xdc, + 0x61, 0x3f, 0xfa, 0xd2, 0x63, 0x32, 0x29, 0xf8, 0xad, 0x49, 0xc7, 0x8a, 0x45, + 0x3c, 0x35, 0x06, 0xd2, 0x28, 0x7b, + ], + [ + 0x33, 0xe5, 0xfe, 0x15, 0x13, 0x0c, 0xa8, 0x67, 0xd6, 0x67, 0x84, 0xa0, 0x43, + 0x26, 0x26, 0xae, 0x9d, 0x1e, 0x62, 0xfb, + ], + [ + 0xf0, 0xbf, 0xf8, 0xdc, 0x02, 0x0a, 0x3d, 0xa2, 0x2d, 0x67, 0xc6, 0x6a, 0x7c, + 0x9c, 0x09, 0x10, 0x47, 0xc7, 0x40, 0x3c, 0xcc, 0x92, 0x23, 0x83, 0xea, 0xaf, + 0xf2, 0x19, 0xed, 0x5e, 0x02, 0x00, + ], + [ + 0x6a, 0xd7, 0x1a, 0x9f, 0xb6, 0x59, 0xfb, 0x71, 0xc1, 0x4c, 0x56, 0x50, 0x35, + 0x3d, 0xe5, 0xbc, 0xdb, 0x64, 0x1b, 0xe9, 0x76, 0x9a, 0xbd, 0x75, 0x5f, 0xdb, + 0xcd, 0xa7, 0x45, 0x57, 0x48, 0x02, 0x68, 0x6f, 0x39, 0x82, 0xa4, 0xa5, 0x6d, + 0xbf, 0x94, 0x4b, 0x31, 0x5f, 0xa6, 0xf5, 0x2b, 0xe4, + ], + [ + 0xdd, 0x67, 0x25, 0xd6, 0x97, 0xa6, 0xf0, 0xfa, 0xb1, 0x0b, 0x61, 0x14, 0x07, + 0x73, 0x12, 0x37, 0x74, 0x91, 0x7c, 0x72, 0xe1, 0xdf, 0x4c, 0x05, 0x9a, 0xc1, + 0x84, 0x66, 0x0c, 0xb6, 0x94, 0x21, 0x2b, 0x22, 0x1c, 0x2b, 0x0e, 0xd4, 0x1b, + 0xcf, 0xfb, 0xbc, 0xbb, 0x46, 0x03, 0x0b, 0xde, 0x77, 0x67, 0xf8, 0xa6, 0x06, + 0xa2, 0x6c, 0x7a, 0x92, 0x6e, 0x9f, 0xa9, 0x83, 0x14, 0xd3, 0x4b, 0x9b, + ] + ), + test_case!( + [ + 0xdc, 0x62, 0x11, 0x60, 0x97, 0xf2, 0x10, 0x7d, 0xe9, 0xa2, 0xd5, 0xc7, 0xd4, + 0x21, 0x0f, 0x82, 0x31, 0x0f, 0xbd, 0x2f, 0x3d, 0x0c, 0xaf, 0x16, 0x70, 0x5f, + 0xe3, 0x93, 0xac, 0x48, 0x08, 0x4c, 0x6c, + ], + [ + 0x27, 0x34, 0x2f, 0x59, 0x11, 0x5f, 0x41, 0xc1, 0x4d, 0xa1, 0x12, 0x59, 0x8e, + 0x0f, 0x85, 0x74, 0x85, 0x73, 0xe1, 0x1b, + ], + [ + 0x12, 0xe1, 0x41, 0xca, 0x13, 0x3b, 0xee, 0xdb, 0x18, 0xbe, 0xf2, 0xfd, 0x8e, + 0x2a, 0xff, 0xb2, 0x9f, 0x40, 0xd3, 0x16, 0x01, 0xfc, 0x2d, 0x76, 0x9f, 0x7a, + 0xf0, 0x39, 0xb3, 0x97, 0x4a, 0x7d, + ], + [ + 0x3b, 0x6e, 0x51, 0x91, 0x8b, 0x7d, 0x02, 0x3d, 0x1c, 0x4b, 0xba, 0xe3, 0xba, + 0x39, 0x70, 0x10, 0x0e, 0xd3, 0x05, 0x83, 0xd8, 0x42, 0x49, 0x27, 0xde, 0x61, + 0x81, 0x29, 0xfe, 0xc4, 0x42, 0x3d, 0x18, 0xc3, 0x9c, 0x9a, 0x26, 0x71, 0x11, + 0x7e, 0xb1, 0xd6, 0x74, 0x4f, 0xd2, 0xaa, 0x60, 0x9f, + ], + [ + 0xc2, 0x72, 0xff, 0xe7, 0x5f, 0x13, 0xcf, 0xb3, 0xf7, 0x3d, 0x76, 0x5c, 0x45, + 0xe8, 0x95, 0x43, 0x22, 0x0f, 0x42, 0xd2, 0xfe, 0x6b, 0x9c, 0x88, 0xf9, 0x43, + 0x8f, 0x3e, 0x8d, 0x54, 0x0d, 0xe9, 0xde, 0xe0, 0xcd, 0x84, 0x8b, 0xca, 0xbd, + 0x67, 0x07, 0x11, 0x0d, 0x1d, 0x99, 0xe8, 0xb2, 0x7f, 0xff, 0x97, 0x1f, 0x16, + 0xd7, 0xf4, 0x5f, 0x04, 0x8e, 0x89, 0x97, 0xcd, 0xff, 0x56, 0x58, 0xcc, + ] + ), + test_case!( + [ + 0x6f, 0x56, 0xad, 0xd8, 0x88, 0xaa, 0xe5, 0x66, 0xc6, 0xee, 0x07, 0xf5, 0x26, + 0x3e, 0xc7, 0xd7, 0x29, 0xf3, 0xc3, 0x0c, 0xe6, 0x0f, 0x7e, 0x12, 0x8a, 0x9a, + 0xa1, 0x61, 0x90, 0xe1, 0x65, 0x53, 0x51, 0x79, + ], + [ + 0x30, 0xac, 0x24, 0xff, 0x40, 0x9b, 0x5b, 0x10, 0x49, 0x9c, 0x18, 0xfb, 0xf8, + 0xba, 0x32, 0xf0, 0x45, 0x28, 0x1a, 0xc2, + ], + [ + 0x5c, 0x18, 0x9a, 0x98, 0x5a, 0xcc, 0x69, 0xe2, 0x9d, 0xe6, 0xd7, 0xd2, 0xb2, + 0x53, 0x07, 0x4a, 0xcd, 0x39, 0xc5, 0x92, 0x14, 0x1f, 0xbf, 0x67, 0x1b, 0x5a, + 0x29, 0x47, 0xcd, 0xc2, 0x38, 0x6f, + ], + [ + 0x00, 0x20, 0x20, 0x82, 0x9f, 0x45, 0xd8, 0x34, 0xae, 0x4a, 0xd6, 0xcd, 0x37, + 0xe4, 0x9c, 0x91, 0x39, 0xad, 0xf9, 0xaf, 0xae, 0x1c, 0x09, 0x6f, 0x32, 0x95, + 0xc9, 0xe2, 0xcf, 0x59, 0x04, 0xec, 0x27, 0xd8, 0x94, 0x2a, 0xce, 0xd8, 0xd1, + 0xff, 0xd9, 0x9f, 0x2d, 0x0e, 0x32, 0x45, 0x2c, 0xce, + ], + [ + 0x7a, 0x4d, 0x9a, 0x8e, 0x1a, 0x7a, 0x7a, 0x18, 0x44, 0xfb, 0x50, 0xce, 0xbc, + 0x71, 0x8b, 0xe6, 0x06, 0x8e, 0x2b, 0xd1, 0x3e, 0x82, 0xee, 0xdb, 0xd0, 0x55, + 0xa9, 0xb8, 0xb6, 0x79, 0xc9, 0x61, 0xcb, 0x06, 0xbe, 0xaf, 0x89, 0x2d, 0xde, + 0x7b, 0x06, 0x44, 0xba, 0xdb, 0xe3, 0xf5, 0xda, 0x6b, 0x61, 0x63, 0x19, 0x2e, + 0xf0, 0xd9, 0xe1, 0xb3, 0xce, 0x5e, 0xf5, 0x3b, 0x6a, 0x82, 0x2e, 0x62, + ] + ), + test_case!( + [ + 0x51, 0xf3, 0x34, 0xe7, 0x7e, 0xcc, 0x29, 0x8c, 0x68, 0x57, 0xec, 0xe7, 0x86, + 0x8b, 0xde, 0xd4, 0x64, 0xa3, 0x30, 0xe3, 0x2d, 0xd1, 0x39, 0xb1, 0x06, 0xe0, + 0x66, 0xb7, 0x99, 0x34, 0xa9, 0x70, 0x1b, 0x18, 0xa6, + ], + [ + 0xd0, 0x87, 0xbc, 0xb9, 0xac, 0x61, 0xd6, 0xd9, 0x5e, 0xc1, 0x44, 0x6e, 0x97, + 0x01, 0xe9, 0xc3, 0x2c, 0x34, 0x7e, 0x94, + ], + [ + 0xdf, 0x9b, 0x7b, 0x38, 0x62, 0x03, 0x07, 0x80, 0x9e, 0x4f, 0x99, 0xa3, 0x34, + 0x37, 0x2d, 0xb1, 0xbb, 0x6b, 0x81, 0x89, 0xa1, 0x25, 0x79, 0x8e, 0x90, 0xb9, + 0xa5, 0x2b, 0x67, 0x43, 0x61, 0xeb, + ], + [ + 0x1f, 0x29, 0x36, 0xe6, 0x63, 0x36, 0x87, 0xb2, 0x35, 0xe0, 0xba, 0x66, 0x3a, + 0x91, 0xdc, 0x97, 0x71, 0xd3, 0x39, 0x60, 0x7c, 0x85, 0x2f, 0x6a, 0x4a, 0x60, + 0xf8, 0x43, 0x4a, 0x94, 0x85, 0xe3, 0x4d, 0xee, 0xfb, 0x18, 0x5c, 0x77, 0xad, + 0xdb, 0xd7, 0xb1, 0x70, 0xd9, 0x95, 0x17, 0xa8, 0x1c, + ], + [ + 0x84, 0xc2, 0x32, 0xd8, 0x6d, 0xb9, 0x62, 0x96, 0x94, 0x7c, 0xbf, 0x6b, 0xd1, + 0x05, 0xf5, 0xe4, 0xfe, 0x6b, 0x66, 0x69, 0x3b, 0x6c, 0x35, 0xb3, 0x11, 0x28, + 0xd9, 0x67, 0x7a, 0xb7, 0xa6, 0x37, 0x1f, 0x75, 0x2a, 0xf9, 0x31, 0x3c, 0xcb, + 0xf7, 0xb4, 0xd6, 0xfb, 0x39, 0xbb, 0x98, 0xe4, 0x32, 0x90, 0xf6, 0x01, 0x8d, + 0x20, 0x27, 0x7e, 0xad, 0x9e, 0x04, 0x30, 0x32, 0x12, 0x83, 0x5e, 0x09, + ] + ), + test_case!( + [ + 0x74, 0x3a, 0x02, 0xd0, 0x15, 0xee, 0xdd, 0x7a, 0x0b, 0xbd, 0x52, 0x00, 0x99, + 0xce, 0x2c, 0xc5, 0xbd, 0x5e, 0x56, 0xba, 0x28, 0x48, 0xf3, 0xa7, 0x3c, 0xaf, + 0x62, 0x6e, 0xf1, 0x9d, 0x78, 0x01, 0xfb, 0xf1, 0x56, 0xf6, + ], + [ + 0xeb, 0x3c, 0x1d, 0xaf, 0x0d, 0x1c, 0x66, 0x57, 0x99, 0xf1, 0xaf, 0xbe, 0xb1, + 0xff, 0xbf, 0xf4, 0x8c, 0x11, 0x16, 0x8f, + ], + [ + 0x5b, 0x67, 0x80, 0xf1, 0x41, 0x6b, 0x0b, 0xf5, 0x0d, 0xc7, 0x92, 0xf7, 0x96, + 0x1e, 0xca, 0xaf, 0x91, 0x8d, 0xba, 0xfb, 0x8f, 0xea, 0x75, 0xcf, 0xf9, 0xd8, + 0xc5, 0x88, 0xa2, 0x96, 0x72, 0x15, + ], + [ + 0xa3, 0xa6, 0xfc, 0xfa, 0x55, 0x1c, 0xbc, 0xf3, 0x25, 0x1b, 0x80, 0xb8, 0xd4, + 0xe1, 0x95, 0x3a, 0xaf, 0xb7, 0x13, 0x7e, 0xa0, 0x88, 0x9e, 0xc8, 0xa9, 0x33, + 0xca, 0xda, 0x93, 0x4b, 0x12, 0x4f, 0xd2, 0x85, 0xbb, 0x49, 0x01, 0xc8, 0x26, + 0x01, 0x3f, 0x0e, 0xfa, 0x12, 0x5e, 0x44, 0x14, 0xb4, + ], + [ + 0x19, 0xa5, 0x0c, 0xae, 0x5f, 0x4d, 0x6a, 0xdb, 0x19, 0x03, 0x58, 0x88, 0xf3, + 0x44, 0xed, 0x4e, 0xdf, 0xc2, 0x2d, 0xe3, 0xd7, 0x2d, 0xba, 0x63, 0xa6, 0x2a, + 0x0b, 0x12, 0x40, 0x78, 0x5a, 0x06, 0xd7, 0xe8, 0x16, 0x38, 0x87, 0x75, 0x15, + 0x24, 0xe1, 0xa0, 0xde, 0x44, 0x5c, 0x47, 0x84, 0x38, 0x3d, 0xc6, 0x06, 0xff, + 0xad, 0x6e, 0x2d, 0xbe, 0x3c, 0xb1, 0x4a, 0x67, 0xc7, 0x82, 0x91, 0x8e, + ] + ), + test_case!( + [ + 0xee, 0x55, 0x5c, 0x2e, 0x82, 0x69, 0x79, 0x10, 0xa0, 0x46, 0x7b, 0x3a, 0x9a, + 0xd4, 0xbe, 0x62, 0xc3, 0x57, 0xc9, 0x57, 0x6b, 0xfe, 0x0f, 0x75, 0x2e, 0xb9, + 0x3a, 0x21, 0x5e, 0xb4, 0x65, 0x56, 0x20, 0xf2, 0xa3, 0x33, 0x7c, + ], + [ + 0x5c, 0xc1, 0x0f, 0x43, 0x53, 0x49, 0xd7, 0x56, 0x56, 0x05, 0x4d, 0x16, 0xaf, + 0xbc, 0x1b, 0xc5, 0xd7, 0x67, 0xbf, 0xf6, + ], + [ + 0x92, 0xd9, 0x3f, 0xf3, 0x71, 0x99, 0x45, 0x7f, 0x40, 0x38, 0x0f, 0x1a, 0x1c, + 0x34, 0xf8, 0x09, 0xa1, 0x20, 0x41, 0xb0, 0xa1, 0x19, 0x2f, 0xcc, 0x5a, 0xab, + 0xe3, 0xcc, 0xcf, 0x50, 0xb0, 0xb2, + ], + [ + 0x0e, 0xc7, 0x58, 0x8b, 0x1f, 0x59, 0x71, 0x4b, 0x06, 0x5e, 0x75, 0x67, 0x52, + 0xbe, 0x56, 0xec, 0xdd, 0x83, 0x49, 0x0c, 0x7f, 0x1b, 0xa1, 0x05, 0x68, 0xaf, + 0xf9, 0x1e, 0x48, 0x7b, 0x9c, 0xcf, 0x03, 0xea, 0xbf, 0xff, 0x0a, 0x88, 0x61, + 0xfd, 0xf0, 0x02, 0xb8, 0x6a, 0x2e, 0xc5, 0xb3, 0x3a, + ], + [ + 0x13, 0x16, 0x50, 0xf5, 0x2a, 0x49, 0x75, 0x05, 0xb8, 0x03, 0x78, 0x00, 0xed, + 0x7e, 0x5e, 0x3a, 0x69, 0xf7, 0x3b, 0x9a, 0x46, 0xef, 0xf0, 0xc9, 0x96, 0xa1, + 0xdb, 0x08, 0x0f, 0x13, 0x58, 0xa3, 0x18, 0xca, 0x09, 0x1e, 0xe6, 0xfc, 0x18, + 0x0c, 0xd0, 0xad, 0x90, 0x56, 0xef, 0xc3, 0x19, 0xeb, 0x46, 0x37, 0x45, 0x64, + 0x1c, 0x81, 0x42, 0x39, 0x4d, 0x46, 0x10, 0x04, 0xe9, 0x4d, 0x8a, 0xa6, + ] + ), + test_case!( + [ + 0xd7, 0x88, 0x2d, 0x5a, 0xee, 0x5a, 0xbb, 0x51, 0xe0, 0x48, 0xfd, 0xed, 0xfa, + 0x23, 0xa6, 0xde, 0x55, 0x68, 0x3e, 0x58, 0x56, 0x45, 0x0f, 0x12, 0x73, 0x7b, + 0xd7, 0xc7, 0xeb, 0x88, 0xf6, 0x57, 0xad, 0x64, 0x77, 0x09, 0x46, 0x55, + ], + [ + 0x16, 0x09, 0x24, 0xdb, 0x8f, 0x81, 0xc5, 0x6d, 0x84, 0xc8, 0x52, 0x2e, 0x1b, + 0x20, 0xb4, 0x09, 0x29, 0x0a, 0x48, 0xed, + ], + [ + 0x37, 0xe0, 0xf2, 0xa5, 0x5f, 0xf6, 0xcb, 0x9c, 0x1c, 0xbd, 0x96, 0x6f, 0xf1, + 0x0f, 0x80, 0xd5, 0xcb, 0xe9, 0xf4, 0xfa, 0x40, 0x4f, 0x0d, 0x36, 0xa4, 0xb7, + 0x5b, 0x4a, 0x3a, 0xe3, 0xb1, 0xb8, + ], + [ + 0x9f, 0xce, 0x73, 0xb7, 0x50, 0xa7, 0x7d, 0x5f, 0xd9, 0x76, 0x49, 0xf9, 0x9e, + 0xc5, 0xb9, 0x4a, 0x9b, 0x25, 0xcf, 0x0b, 0x14, 0x49, 0xfc, 0xd6, 0x9f, 0x3d, + 0xcf, 0x1d, 0xb8, 0xbc, 0x45, 0xda, 0x11, 0x02, 0xb3, 0x0a, 0x43, 0x65, 0x33, + 0xb6, 0xf5, 0xe8, 0x9c, 0x60, 0x8b, 0x7b, 0x38, 0x79, + ], + [ + 0x34, 0xff, 0x6e, 0x2b, 0xa9, 0x2a, 0x37, 0x3a, 0x21, 0x4f, 0xbd, 0x6c, 0x4c, + 0x81, 0xea, 0xfc, 0xa6, 0xc4, 0xc6, 0xb1, 0x73, 0x51, 0x32, 0x10, 0x7a, 0x02, + 0x87, 0x80, 0x81, 0x7e, 0xfd, 0x20, 0x97, 0x63, 0xa7, 0x96, 0xba, 0xa4, 0x29, + 0x49, 0xad, 0x78, 0x24, 0xe7, 0x72, 0xac, 0x37, 0x86, 0x86, 0xd5, 0x42, 0x25, + 0x94, 0x59, 0xec, 0x97, 0x74, 0x70, 0x7f, 0x2c, 0x2c, 0x95, 0x9b, 0x18, + ] + ), + test_case!( + [ + 0xfd, 0xec, 0xa1, 0xea, 0xd1, 0x0f, 0x2d, 0xb9, 0x2e, 0xce, 0x0f, 0x10, 0x28, + 0xb5, 0x8a, 0x23, 0xfd, 0xed, 0xc1, 0x64, 0xab, 0xfc, 0x52, 0x9d, 0x17, 0xe5, + 0x44, 0x29, 0xd3, 0x76, 0x1b, 0xe7, 0x99, 0xf5, 0x47, 0xa9, 0xc4, 0xb6, 0x55, + ], + [ + 0x70, 0x84, 0x56, 0xb0, 0xb7, 0xa0, 0x97, 0x3d, 0x11, 0x27, 0x60, 0xd2, 0x88, + 0x67, 0x5c, 0xca, 0x8e, 0x44, 0xfc, 0x93, + ], + [ + 0x9f, 0xb9, 0x5b, 0x27, 0x10, 0xe7, 0x13, 0xb0, 0x9d, 0x35, 0xe2, 0x68, 0x4c, + 0x8c, 0x01, 0x63, 0xcd, 0xc1, 0xf2, 0x01, 0x30, 0x10, 0x42, 0x87, 0xe4, 0xa3, + 0x22, 0x35, 0x55, 0xbc, 0xfb, 0x96, + ], + [ + 0x5e, 0x04, 0xa0, 0x59, 0x2e, 0xf1, 0xe6, 0xf2, 0x18, 0xd8, 0xdc, 0xa6, 0xf8, + 0xf7, 0x88, 0x32, 0xa1, 0xec, 0x48, 0x04, 0xfc, 0xa7, 0xf6, 0xa2, 0x8b, 0x3e, + 0x8f, 0x7e, 0xa8, 0x64, 0x87, 0x25, 0x4b, 0xba, 0xc7, 0x27, 0x4c, 0xee, 0xe4, + 0x93, 0xbb, 0x1d, 0x62, 0x71, 0xfc, 0xe1, 0x22, 0x54, + ], + [ + 0x03, 0x7c, 0x2c, 0x76, 0x85, 0xd0, 0xca, 0x2d, 0x9c, 0xbd, 0xe6, 0xe8, 0x42, + 0xd6, 0xcd, 0x65, 0x74, 0xaf, 0xd2, 0x95, 0xfb, 0x8c, 0xc6, 0x25, 0x14, 0x13, + 0x8d, 0x9f, 0x50, 0x59, 0x63, 0x03, 0xc2, 0x29, 0x92, 0x06, 0x22, 0xc8, 0x85, + 0x03, 0x6a, 0x29, 0x84, 0x71, 0xc3, 0xd1, 0x47, 0x49, 0x66, 0x8f, 0xa1, 0xa5, + 0xb3, 0xa6, 0x78, 0x95, 0x98, 0x7e, 0x23, 0x81, 0xc9, 0xd5, 0x4f, 0xd1, + ] + ), + test_case!( + [ + 0x26, 0x66, 0x74, 0xa4, 0x1d, 0x40, 0x05, 0x26, 0x6d, 0xa3, 0x5b, 0xd1, 0xb9, + 0x71, 0xd0, 0xb2, 0xa2, 0xad, 0xd6, 0xa8, 0x77, 0x9d, 0x32, 0xd7, 0x5b, 0x48, + 0xa9, 0x45, 0x52, 0x63, 0x65, 0xe1, 0x49, 0xce, 0x04, 0x25, 0xcf, 0x93, 0x28, + 0x08, + ], + [ + 0x43, 0xe8, 0x6b, 0x9c, 0x6b, 0xcb, 0x9f, 0x02, 0x8a, 0xa3, 0x6a, 0xc8, 0x65, + 0xaa, 0x5d, 0xea, 0xcc, 0x0b, 0xda, 0xc1, + ], + [ + 0xa3, 0x7f, 0xd5, 0x05, 0xc4, 0x36, 0xba, 0xa1, 0xe5, 0x41, 0x73, 0xf2, 0x34, + 0xb3, 0x50, 0xd3, 0x09, 0xd6, 0xbf, 0xeb, 0x5c, 0x43, 0x42, 0xbe, 0x1e, 0xfd, + 0x80, 0x46, 0xc0, 0x26, 0x2a, 0x02, + ], + [ + 0xee, 0x78, 0x5e, 0x97, 0x0d, 0x5e, 0x91, 0x76, 0x2a, 0x52, 0x5f, 0x2e, 0x99, + 0xb6, 0xd0, 0x53, 0x70, 0x8a, 0x34, 0x92, 0x31, 0xa1, 0xaf, 0x1c, 0x7f, 0x5d, + 0xbf, 0x36, 0x6f, 0x32, 0x3c, 0xe7, 0x80, 0xb3, 0x7c, 0x97, 0x7c, 0x09, 0x86, + 0xba, 0x25, 0xea, 0x94, 0x2d, 0xd8, 0x5d, 0xe4, 0x72, + ], + [ + 0xde, 0xd0, 0x30, 0x07, 0xb0, 0x8c, 0x5b, 0x6a, 0xcf, 0xe7, 0xd6, 0x44, 0xdb, + 0x13, 0x7c, 0xcd, 0x46, 0x7b, 0xd3, 0xd7, 0x32, 0x92, 0xb4, 0xde, 0xc0, 0x59, + 0x66, 0x43, 0x03, 0x25, 0x87, 0xb9, 0x60, 0xa8, 0x07, 0xec, 0x3e, 0x5a, 0xe8, + 0x82, 0x99, 0x00, 0x9f, 0x8c, 0xba, 0x60, 0xca, 0x27, 0x08, 0xf1, 0x32, 0xe4, + 0x40, 0xd5, 0x65, 0x62, 0xd1, 0x40, 0x89, 0xc6, 0x01, 0xfb, 0xc6, 0xc6, + ] + ), + test_case!( + [ + 0x20, 0x12, 0x93, 0xbe, 0xea, 0xc8, 0xde, 0x2d, 0xc6, 0x86, 0xe6, 0x33, 0xa5, + 0x00, 0xb6, 0xfb, 0x66, 0x05, 0xd6, 0xbf, 0x03, 0xc5, 0xea, 0x44, 0x15, 0x62, + 0x25, 0x34, 0x58, 0x5d, 0x3b, 0x13, 0x59, 0x20, 0x21, 0x42, 0xfa, 0xb4, 0xbe, + 0x2a, 0xb1, + ], + [ + 0x8c, 0x93, 0xf9, 0x39, 0xd5, 0xe8, 0xe1, 0x89, 0xd1, 0x51, 0x09, 0xe1, 0xe8, + 0x85, 0x36, 0xdf, 0xf0, 0x03, 0xc3, 0x21, + ], + [ + 0x33, 0x5e, 0xfd, 0x1e, 0xf1, 0x3f, 0x9a, 0x36, 0x70, 0xa3, 0x42, 0x75, 0x37, + 0x34, 0x20, 0xbe, 0xb6, 0x09, 0x50, 0x48, 0xd0, 0x6c, 0x63, 0xac, 0xb6, 0x2e, + 0x12, 0xaa, 0xe0, 0xd9, 0xbd, 0xf6, + ], + [ + 0xe9, 0x9d, 0xf0, 0x00, 0xe8, 0x03, 0x98, 0x7a, 0x47, 0x6b, 0x48, 0xd4, 0xc8, + 0xdd, 0x6c, 0xf3, 0xdf, 0x20, 0x69, 0xa0, 0x82, 0xca, 0xe4, 0x32, 0xcc, 0x90, + 0x81, 0x3a, 0x19, 0xea, 0xf6, 0xe7, 0x22, 0x7d, 0x55, 0xd1, 0xee, 0x6e, 0x7d, + 0xe3, 0xa8, 0xdb, 0x9c, 0x73, 0x29, 0xd4, 0xdd, 0xd8, + ], + [ + 0x7a, 0xb9, 0x04, 0x46, 0x5f, 0xc0, 0xdf, 0x7f, 0x3b, 0xb3, 0x92, 0xdc, 0xe8, + 0x58, 0x12, 0xd2, 0xf0, 0x61, 0x82, 0x6e, 0xeb, 0x64, 0x57, 0x14, 0x46, 0xb1, + 0xa6, 0x6a, 0x41, 0x45, 0x2c, 0x44, 0xa8, 0xf9, 0x2c, 0xe5, 0x91, 0xa0, 0x06, + 0x8c, 0xbe, 0xe9, 0xc2, 0x0e, 0x0b, 0x54, 0xad, 0x60, 0x94, 0x24, 0x71, 0x67, + 0xa5, 0xfd, 0x0c, 0x47, 0x0d, 0xb7, 0xe7, 0x0a, 0x52, 0x28, 0x76, 0xfa, + ] + ), + test_case!( + [ + 0x25, 0x24, 0x4e, 0x7d, 0xd3, 0x5c, 0x19, 0x6c, 0x65, 0x4f, 0x27, 0x11, 0xd5, + 0xa9, 0xc6, 0xbe, 0x54, 0xb6, 0xa5, 0xb5, 0x58, 0x52, 0xcc, 0x84, 0x66, 0x23, + 0x15, 0x07, 0x50, 0xc2, 0x3e, 0xf8, 0xe2, 0x8d, 0x36, 0x94, 0x41, 0x65, 0x1a, + 0x65, 0xe3, 0x34, + ], + [ + 0x27, 0x1b, 0x02, 0xa7, 0xaa, 0x9d, 0x9e, 0x4b, 0xbc, 0x8d, 0x61, 0x86, 0x60, + 0x13, 0x02, 0xfa, 0x67, 0x39, 0x55, 0xdf, + ], + [ + 0x6e, 0x61, 0x59, 0xc6, 0x7c, 0x2f, 0x05, 0x87, 0xcf, 0xeb, 0x71, 0x36, 0x85, + 0xf0, 0x89, 0xc1, 0xf7, 0xf4, 0xf9, 0xfb, 0xf8, 0xc2, 0xf9, 0xfd, 0x92, 0xbe, + 0xaa, 0x1d, 0x92, 0xc5, 0x2b, 0x9f, + ], + [ + 0xbc, 0x62, 0x9f, 0x44, 0x9f, 0x8c, 0x83, 0x39, 0x93, 0xda, 0xbe, 0xa0, 0xf8, + 0x91, 0xa9, 0xf9, 0xb5, 0x7c, 0x03, 0x8d, 0x35, 0x56, 0x02, 0xf2, 0xee, 0xff, + 0x4c, 0x32, 0xb3, 0x83, 0xd3, 0x22, 0x46, 0x87, 0x17, 0xf9, 0x77, 0x3e, 0x19, + 0xc6, 0x91, 0x6f, 0xb4, 0x68, 0x7c, 0xd3, 0x0a, 0x6e, + ], + [ + 0x97, 0xa2, 0xce, 0x76, 0xb8, 0x38, 0x72, 0xbe, 0x8b, 0x06, 0x13, 0xf1, 0x94, + 0xfc, 0xd5, 0x15, 0x8d, 0xb8, 0x56, 0xf9, 0x4f, 0x39, 0x65, 0x92, 0x34, 0x2d, + 0x68, 0xcf, 0x26, 0x20, 0x0d, 0x8e, 0x15, 0x97, 0x04, 0x71, 0x12, 0x97, 0x12, + 0x45, 0xad, 0xe2, 0x67, 0x8d, 0xbe, 0x92, 0x97, 0x7a, 0x52, 0x01, 0x0c, 0x84, + 0x40, 0xf2, 0x3d, 0x4b, 0x41, 0x04, 0x34, 0xef, 0x88, 0x59, 0xe1, 0xb7, + ] + ), + test_case!( + [ + 0x35, 0xe2, 0xf7, 0x9c, 0x2a, 0x74, 0x75, 0xfa, 0x8d, 0x56, 0x0f, 0x66, 0xc7, + 0xae, 0xe7, 0x96, 0x64, 0x0d, 0xf8, 0x8b, 0x66, 0x8a, 0xf4, 0x5d, 0x76, 0xd2, + 0x08, 0xc2, 0xf4, 0x46, 0x0e, 0x9d, 0x55, 0x27, 0x1f, 0x12, 0x95, 0x0b, 0xbf, + 0x5f, 0xfc, 0xa8, 0xd2, + ], + [ + 0xda, 0x0a, 0x69, 0x3e, 0x9d, 0xca, 0x7f, 0x85, 0x5c, 0xd5, 0x28, 0x07, 0xeb, + 0x1f, 0xde, 0xc6, 0x17, 0xa8, 0xab, 0xd3, + ], + [ + 0x71, 0x36, 0xfe, 0x0b, 0xf1, 0x1a, 0xf8, 0x79, 0x52, 0x97, 0xb1, 0x33, 0x4d, + 0x2d, 0x29, 0x4b, 0xe4, 0x8d, 0x47, 0x02, 0x36, 0xe6, 0x66, 0x45, 0xb9, 0x67, + 0xb8, 0xe9, 0xe6, 0xbe, 0xd7, 0xc0, + ], + [ + 0x59, 0x74, 0x0e, 0x65, 0xca, 0x44, 0xa5, 0x2e, 0x39, 0x55, 0x85, 0x56, 0x17, + 0xc0, 0x50, 0x8e, 0x60, 0x90, 0xc8, 0x0d, 0xbe, 0x1b, 0x8d, 0x0e, 0x7c, 0xba, + 0xa6, 0xa2, 0xe6, 0x24, 0xf6, 0x7e, 0xc8, 0x9e, 0x6b, 0x66, 0xce, 0x35, 0x50, + 0x44, 0x37, 0x62, 0xb7, 0x90, 0x2f, 0xec, 0x27, 0x6a, + ], + [ + 0x00, 0x13, 0x62, 0xed, 0x76, 0x71, 0xaf, 0x24, 0xf5, 0x64, 0x20, 0xd6, 0x23, + 0xf2, 0x26, 0xf7, 0xd3, 0x2e, 0xfa, 0xe4, 0xcb, 0x66, 0xd4, 0x5c, 0x2a, 0x9f, + 0x84, 0xc3, 0x5c, 0xd8, 0x5f, 0x98, 0x8a, 0x53, 0x1f, 0x29, 0x45, 0xb4, 0x82, + 0xf8, 0xea, 0x1a, 0x5d, 0xaa, 0xe0, 0x34, 0xdb, 0xc6, 0x0f, 0xd8, 0x7c, 0x47, + 0x9d, 0x50, 0x28, 0x3a, 0xec, 0x7c, 0x25, 0x15, 0xbe, 0xa4, 0xf8, 0x3b, + ] + ), + test_case!( + [ + 0x1a, 0xc5, 0x22, 0x68, 0xc0, 0x9f, 0x87, 0xfc, 0x6a, 0x92, 0x3b, 0xc9, 0x69, + 0xfb, 0x43, 0x54, 0xa5, 0x10, 0x9c, 0x46, 0xf6, 0xb4, 0xa2, 0xd3, 0xe4, 0xd9, + 0xa6, 0x10, 0x0f, 0x4e, 0x1f, 0x73, 0x82, 0xe6, 0x2e, 0x8b, 0x91, 0xfe, 0x5c, + 0x58, 0x32, 0x05, 0x7f, 0x68, + ], + [ + 0xbf, 0x02, 0xa6, 0x5f, 0xec, 0x11, 0x24, 0xb7, 0xcd, 0x7c, 0x9d, 0xba, 0x2f, + 0xa0, 0xb0, 0x46, 0xff, 0x30, 0xd2, 0x86, + ], + [ + 0x67, 0x96, 0xa7, 0xc3, 0x09, 0x09, 0xf3, 0xa3, 0x94, 0x7d, 0x36, 0x9c, 0xb7, + 0x4b, 0x9f, 0x72, 0xf2, 0x59, 0x19, 0x5f, 0xb9, 0x08, 0x63, 0xf2, 0x2c, 0xfb, + 0x91, 0x2e, 0x2a, 0x77, 0xc9, 0x63, + ], + [ + 0x38, 0xef, 0xde, 0xc2, 0xf7, 0xb4, 0xc5, 0x89, 0xe9, 0x06, 0x8a, 0x57, 0xcd, + 0x0b, 0x9e, 0x5a, 0x66, 0xe7, 0xe5, 0xd9, 0xef, 0xfa, 0xc6, 0xa8, 0xa6, 0x43, + 0xc6, 0xcd, 0x57, 0x93, 0x87, 0x8d, 0x92, 0x7a, 0xdc, 0x50, 0xff, 0x45, 0xad, + 0xdc, 0x7c, 0xe3, 0x46, 0xb8, 0x1a, 0x86, 0x3e, 0xd8, + ], + [ + 0xd9, 0x2e, 0x8a, 0x61, 0x20, 0x24, 0x4e, 0x1a, 0x56, 0x2b, 0x76, 0xd5, 0xc7, + 0xcf, 0x69, 0xc7, 0x3a, 0xbd, 0xbb, 0x88, 0x3d, 0xe9, 0x16, 0x88, 0x7b, 0x32, + 0x8c, 0xde, 0x79, 0xa6, 0x03, 0x68, 0x7d, 0xef, 0x83, 0x71, 0xe9, 0xef, 0xdd, + 0x13, 0x36, 0x9b, 0xe5, 0x36, 0xa5, 0x60, 0x21, 0x9d, 0xc2, 0x9c, 0xa3, 0xff, + 0x3a, 0x54, 0xfa, 0xd7, 0x77, 0xa9, 0x50, 0x12, 0xfc, 0x14, 0xbc, 0x3f, + ] + ), + test_case!( + [ + 0xfb, 0x6b, 0xac, 0xbe, 0x3a, 0x17, 0x39, 0x5a, 0x3c, 0x2b, 0x5c, 0x37, 0x9f, + 0xea, 0xf0, 0xf0, 0x64, 0x51, 0x36, 0xce, 0x1a, 0xe5, 0x95, 0x7b, 0x9f, 0x95, + 0x0b, 0x56, 0x9b, 0x09, 0x2d, 0xc8, 0x11, 0x36, 0xea, 0x1b, 0x99, 0x93, 0xe0, + 0x9a, 0x66, 0xb0, 0xa1, 0x4a, 0x66, + ], + [ + 0xab, 0x81, 0x02, 0x81, 0x1a, 0x8c, 0x3b, 0xb3, 0x1d, 0x11, 0x1a, 0xe9, 0x51, + 0xa0, 0x0e, 0xd5, 0xa3, 0x9c, 0x5b, 0x96, + ], + [ + 0xda, 0xb8, 0x83, 0x7a, 0x4f, 0xb7, 0x69, 0x05, 0x3a, 0xa4, 0x75, 0x01, 0xed, + 0xe9, 0x0f, 0xf7, 0xbd, 0x9b, 0xe6, 0x93, 0x9e, 0x44, 0x0f, 0x42, 0x6a, 0x2c, + 0x66, 0xa0, 0x23, 0x9d, 0xed, 0xea, + ], + [ + 0x12, 0x1f, 0xa1, 0x78, 0x49, 0xd4, 0x36, 0x1c, 0xf4, 0xbc, 0x13, 0x85, 0x13, + 0xdf, 0x89, 0x5a, 0x95, 0xc3, 0xa1, 0xd6, 0xf3, 0xd0, 0x2f, 0xad, 0xb1, 0x9d, + 0x00, 0x84, 0xe8, 0x13, 0xb1, 0x66, 0xfd, 0x94, 0xd0, 0x02, 0xdc, 0x43, 0x9c, + 0xaf, 0x59, 0x11, 0x2b, 0x82, 0x24, 0x08, 0xe5, 0xb4, + ], + [ + 0x33, 0x34, 0xcd, 0xbc, 0x7e, 0xcb, 0xea, 0xa8, 0xe4, 0x4a, 0xc5, 0xf9, 0x28, + 0xf9, 0x6b, 0x56, 0xc7, 0xb8, 0xb9, 0x90, 0xb2, 0xbd, 0x8a, 0xef, 0x99, 0x89, + 0x52, 0x62, 0x02, 0x9e, 0xf5, 0x26, 0x77, 0x5a, 0x4a, 0xa3, 0xc6, 0xa5, 0xf2, + 0x58, 0xcb, 0xa8, 0x99, 0xa6, 0x52, 0x85, 0xfe, 0xd7, 0x75, 0xae, 0x13, 0x70, + 0x10, 0x85, 0xf9, 0x0a, 0xa0, 0xc6, 0x7d, 0xd3, 0x59, 0xbb, 0x55, 0x01, + ] + ), + test_case!( + [ + 0xaa, 0xdf, 0xb1, 0x66, 0x9c, 0x82, 0x45, 0x46, 0x36, 0x07, 0x8b, 0x78, 0x8b, + 0x67, 0xe3, 0x6d, 0xfa, 0x2a, 0xa2, 0xa2, 0x1d, 0xb6, 0x35, 0x19, 0x9b, 0xd9, + 0x5a, 0xa2, 0x5b, 0x96, 0xd1, 0xb4, 0x68, 0x00, 0xc0, 0x8c, 0x17, 0x50, 0x83, + 0x66, 0xbf, 0x83, 0x94, 0xd8, 0x46, 0x68, + ], + [ + 0x9b, 0xd0, 0xb5, 0x2d, 0x27, 0x7f, 0x23, 0xa6, 0x32, 0xc2, 0xa8, 0x4a, 0x2d, + 0x61, 0x06, 0xae, 0x77, 0x63, 0x22, 0x14, + ], + [ + 0xc2, 0x27, 0xd1, 0x71, 0x74, 0xf2, 0x4e, 0x1a, 0x98, 0x09, 0x1b, 0xb0, 0x2f, + 0xc0, 0x9f, 0xdf, 0x39, 0x0b, 0x60, 0x68, 0x37, 0x58, 0x21, 0x88, 0x0e, 0x58, + 0x46, 0x2b, 0x08, 0x99, 0xb8, 0x03, + ], + [ + 0x31, 0xf2, 0xfd, 0xcd, 0x14, 0x19, 0x81, 0xe7, 0x29, 0x43, 0xbb, 0x27, 0xad, + 0x19, 0x17, 0x5a, 0xd4, 0xc4, 0x9d, 0x34, 0x0e, 0x6e, 0x74, 0xe4, 0x0f, 0xf4, + 0x0e, 0xb7, 0x19, 0xd7, 0xdc, 0x19, 0x89, 0xba, 0x2c, 0xe7, 0x8b, 0xed, 0xe8, + 0x10, 0x21, 0x15, 0x1d, 0x8b, 0x66, 0xdf, 0x37, 0x48, + ], + [ + 0x1e, 0xd3, 0x26, 0xc3, 0xf3, 0x01, 0x12, 0x37, 0xdb, 0x2f, 0xd9, 0x33, 0x8d, + 0xb1, 0x3e, 0x7d, 0x50, 0xe4, 0xe8, 0xda, 0x8a, 0x5d, 0x4a, 0x02, 0xa3, 0x24, + 0xfc, 0x9d, 0x0e, 0x5e, 0x1b, 0x73, 0x97, 0x2a, 0xbd, 0xe3, 0x04, 0x6d, 0x54, + 0xcc, 0xd9, 0x67, 0xa5, 0xdf, 0x37, 0xc6, 0x6c, 0x9a, 0x2c, 0xb7, 0x12, 0x80, + 0x18, 0xd6, 0x94, 0x4a, 0xc1, 0x19, 0x7b, 0x4c, 0x26, 0x58, 0x12, 0x31, + ] + ), + test_case!( + [ + 0xd7, 0x65, 0xb5, 0x5a, 0x5b, 0x5e, 0xe0, 0xd6, 0xda, 0x29, 0xcb, 0x42, 0xe1, + 0x2a, 0x89, 0x9f, 0x7f, 0x23, 0xaa, 0x27, 0xca, 0x30, 0xbf, 0x33, 0x48, 0x16, + 0x5c, 0x7c, 0x74, 0xe8, 0x92, 0x06, 0x75, 0x73, 0xd1, 0x55, 0xee, 0x73, 0x40, + 0xd2, 0xe9, 0xd0, 0x58, 0xc6, 0x1a, 0x2b, 0x00, + ], + [ + 0xec, 0x56, 0xeb, 0x62, 0xb8, 0xa0, 0xe0, 0x57, 0xcc, 0x82, 0x3d, 0x82, 0xe9, + 0xc7, 0xa2, 0x2b, 0x1b, 0x61, 0xab, 0x16, + ], + [ + 0xe1, 0x8d, 0x9d, 0xb0, 0x00, 0x61, 0x5c, 0x28, 0x09, 0x7a, 0xbe, 0xb6, 0x77, + 0xd8, 0xb4, 0xa7, 0x0b, 0x2f, 0xd1, 0xaf, 0x58, 0x69, 0xb3, 0xa1, 0x81, 0x03, + 0x87, 0xed, 0x69, 0x58, 0x89, 0xb0, + ], + [ + 0x22, 0x06, 0xed, 0xa0, 0x52, 0xd5, 0x70, 0xef, 0xed, 0xe8, 0x56, 0xd0, 0x0d, + 0x53, 0x42, 0xdf, 0xd3, 0xfd, 0x0f, 0x0a, 0x17, 0x6b, 0x7b, 0x46, 0xef, 0xeb, + 0xda, 0x8a, 0x3c, 0xb4, 0x0b, 0xcf, 0x23, 0xb4, 0xde, 0xb9, 0x1d, 0x1a, 0x47, + 0x26, 0xa3, 0x3e, 0x3c, 0xb4, 0xbb, 0x23, 0xa1, 0xe7, + ], + [ + 0x40, 0x6a, 0x54, 0x7c, 0x7d, 0x7a, 0x7d, 0x3f, 0xae, 0xaf, 0xba, 0x91, 0x3b, + 0xc0, 0x48, 0x58, 0x24, 0x29, 0x49, 0x57, 0x53, 0x32, 0xfe, 0xb9, 0x45, 0xfb, + 0xd6, 0x91, 0xef, 0xb5, 0x16, 0x94, 0x58, 0x14, 0x2a, 0xa2, 0x41, 0x61, 0x19, + 0x8a, 0x36, 0x04, 0x94, 0xd8, 0xdc, 0xdd, 0x8d, 0x0c, 0xc2, 0xef, 0x50, 0x11, + 0x17, 0x49, 0x6d, 0x58, 0x74, 0xb1, 0x9d, 0xfb, 0x43, 0x62, 0xde, 0x1f, + ] + ), + test_case!( + [ + 0xe4, 0x88, 0xe3, 0x3d, 0xfc, 0x4a, 0x48, 0xd2, 0xf3, 0x7f, 0x1f, 0xa8, 0x47, + 0x20, 0x6e, 0x6e, 0x87, 0x20, 0x47, 0x78, 0x1d, 0xfb, 0x3c, 0x5c, 0xbb, 0xfb, + 0x5d, 0xb3, 0x5a, 0x92, 0x37, 0x57, 0x84, 0xef, 0x51, 0xc0, 0x29, 0x29, 0xd3, + 0x13, 0x6e, 0x42, 0x86, 0xef, 0x4e, 0x53, 0xd5, 0x54, + ], + [ + 0xc5, 0x38, 0xe5, 0x28, 0x99, 0x0d, 0xbc, 0x8f, 0xec, 0x2c, 0x2d, 0x74, 0x9d, + 0x6c, 0x09, 0xce, 0xda, 0xda, 0x01, 0xe4, + ], + [ + 0x7d, 0x1a, 0x96, 0x9b, 0xa1, 0x53, 0xdf, 0x51, 0x75, 0xad, 0xba, 0x2d, 0x85, + 0xe1, 0x80, 0xce, 0x61, 0xf4, 0x4d, 0x62, 0xf8, 0xe6, 0x7e, 0x1f, 0x57, 0x9f, + 0xa2, 0x27, 0x76, 0xbb, 0xd8, 0x27, + ], + [ + 0x38, 0xf4, 0x61, 0xc0, 0x24, 0x5d, 0xd0, 0x99, 0x64, 0xc1, 0x93, 0xb5, 0x92, + 0x3c, 0x45, 0x15, 0x84, 0x91, 0x6c, 0x04, 0xaf, 0xae, 0x31, 0x10, 0x7f, 0x80, + 0x85, 0x3a, 0xd8, 0x32, 0x10, 0xb2, 0xef, 0x07, 0x16, 0x89, 0x6c, 0x35, 0x97, + 0x47, 0x3c, 0x81, 0xc3, 0x18, 0xfe, 0x47, 0xde, 0xd7, + ], + [ + 0x5a, 0xe4, 0x2b, 0xca, 0x16, 0xb9, 0xe8, 0xc8, 0xe5, 0x89, 0x18, 0x15, 0x27, + 0x2f, 0x7c, 0x92, 0x21, 0x19, 0xb1, 0x28, 0x4b, 0x81, 0x09, 0xf4, 0x0d, 0x78, + 0x4f, 0xea, 0xe3, 0x30, 0x0a, 0x51, 0xc2, 0x0f, 0x8e, 0x42, 0xe5, 0x35, 0xde, + 0xb5, 0xd2, 0x94, 0x3f, 0x60, 0x02, 0x12, 0xec, 0x1f, 0x84, 0x6d, 0x82, 0xf4, + 0xf1, 0x06, 0xe9, 0xf0, 0x7b, 0xf7, 0x7a, 0x99, 0x68, 0x93, 0x19, 0x35, + ] + ), + test_case!( + [ + 0xc2, 0x92, 0xa0, 0x25, 0xab, 0xe8, 0x7d, 0x53, 0x61, 0x66, 0x19, 0xf1, 0x5d, + 0xf5, 0x1b, 0xa6, 0x9c, 0x8d, 0x41, 0x3c, 0x05, 0x75, 0xdb, 0x45, 0x7e, 0x08, + 0x9e, 0x99, 0x31, 0x26, 0xf3, 0x5c, 0x84, 0x96, 0xa5, 0x20, 0x27, 0xac, 0xb0, + 0x89, 0xb4, 0x0d, 0x85, 0x00, 0xff, 0xc6, 0xe2, 0x00, 0x58, + ], + [ + 0x7e, 0x9f, 0xa5, 0xf4, 0xf2, 0x9c, 0x6b, 0x2c, 0x87, 0x2f, 0xe1, 0x45, 0x51, + 0x82, 0xa1, 0x80, 0xec, 0xdb, 0x0e, 0x86, + ], + [ + 0x58, 0x04, 0x1b, 0x6a, 0x8d, 0x73, 0xa3, 0x45, 0xb6, 0xed, 0x8f, 0x1b, 0x6a, + 0xef, 0x0b, 0x30, 0x5f, 0xec, 0x4b, 0xa3, 0x83, 0x17, 0x21, 0xb6, 0xb0, 0x79, + 0xac, 0x59, 0x2e, 0x8a, 0x67, 0x2d, + ], + [ + 0x01, 0x5d, 0x3a, 0xf2, 0x62, 0xf0, 0x45, 0x3a, 0xf3, 0x93, 0x6e, 0x65, 0xb5, + 0x39, 0xa1, 0x2f, 0x76, 0x08, 0x9d, 0x1e, 0x8b, 0x51, 0xb0, 0xb7, 0x53, 0x5c, + 0xc8, 0x0e, 0xbe, 0x86, 0x61, 0x74, 0xc4, 0x55, 0x8b, 0xfd, 0xf1, 0xd5, 0x37, + 0x0d, 0xe6, 0xd9, 0x12, 0x31, 0xa3, 0xd8, 0x78, 0x06, + ], + [ + 0x50, 0x6d, 0x1b, 0xb5, 0x95, 0xc2, 0x78, 0xe7, 0x9e, 0x94, 0x3e, 0x4e, 0xb0, + 0x63, 0x28, 0x46, 0x9c, 0x9b, 0x1f, 0xed, 0x99, 0x88, 0x34, 0x4f, 0xde, 0x11, + 0x98, 0xd8, 0xce, 0x72, 0xf7, 0xb4, 0x50, 0x26, 0x33, 0xe0, 0x1f, 0x1a, 0x37, + 0xeb, 0x56, 0x62, 0xaf, 0xbc, 0xa2, 0x0e, 0xf0, 0x02, 0x9a, 0xa1, 0xe9, 0x7b, + 0xbf, 0x34, 0xc1, 0x96, 0x52, 0xb1, 0x1d, 0x59, 0x65, 0x61, 0x66, 0xc0, + ] + ), + test_case!( + [ + 0x97, 0xa9, 0xb4, 0x7b, 0x8b, 0xc3, 0x11, 0x0a, 0x34, 0x30, 0x56, 0x4a, 0xd2, + 0x6e, 0xe8, 0x4e, 0x06, 0xc9, 0x05, 0xbc, 0x8f, 0x52, 0x4a, 0x07, 0x4f, 0x2b, + 0x7a, 0x96, 0x0a, 0x51, 0x9e, 0xdb, 0x28, 0x7b, 0x40, 0xd7, 0x12, 0x08, 0x64, + 0xce, 0xf3, 0xf4, 0x1a, 0x9e, 0xb3, 0x03, 0x8d, 0xf7, 0xe9, 0x57, + ], + [ + 0x65, 0x3d, 0x0d, 0xa5, 0x30, 0x2e, 0xd8, 0x1c, 0xe3, 0xf2, 0x96, 0x37, 0x06, + 0x74, 0x99, 0xae, 0x0f, 0x13, 0xbf, 0x6a, + ], + [ + 0x18, 0x20, 0xd4, 0x9d, 0x02, 0x72, 0xeb, 0xa7, 0x9c, 0x36, 0x5c, 0x2c, 0x37, + 0xc9, 0x03, 0xeb, 0xcd, 0xed, 0x1e, 0xae, 0x46, 0x1d, 0xdf, 0x74, 0x21, 0x43, + 0x76, 0xfd, 0xaf, 0x16, 0xbf, 0x62, + ], + [ + 0xef, 0x67, 0x3b, 0x92, 0x76, 0x44, 0xba, 0xaa, 0x47, 0x22, 0xe3, 0x4d, 0xe3, + 0xb9, 0xbd, 0xb8, 0x4a, 0x90, 0x7b, 0x62, 0xae, 0xec, 0x1c, 0x3a, 0x07, 0xd3, + 0x88, 0x69, 0xb4, 0x16, 0x46, 0x67, 0x94, 0xf3, 0x84, 0xe8, 0xd6, 0xef, 0xfb, + 0xf5, 0x2f, 0x74, 0xd2, 0xd9, 0x4e, 0x23, 0xeb, 0x56, + ], + [ + 0x64, 0x54, 0x09, 0x73, 0x59, 0x36, 0x87, 0x48, 0x06, 0x48, 0xa3, 0xd8, 0x63, + 0x24, 0x7c, 0xbc, 0x38, 0x3a, 0x91, 0x2c, 0x88, 0xf3, 0x6b, 0x12, 0xea, 0x5f, + 0x6c, 0x03, 0x9f, 0x9c, 0xf3, 0x3e, 0xf0, 0x8c, 0x4b, 0x94, 0xc0, 0x50, 0xc9, + 0x33, 0x37, 0x61, 0x7e, 0xb6, 0x32, 0xbc, 0x26, 0xf7, 0xcc, 0x9c, 0x6e, 0x0e, + 0x49, 0xa8, 0x8d, 0x94, 0x88, 0x48, 0x75, 0xda, 0x1e, 0x34, 0x58, 0xe1, + ] + ), + test_case!( + [ + 0xff, 0x53, 0xbe, 0x51, 0x7b, 0x99, 0xa3, 0xe8, 0xae, 0xcb, 0xc5, 0xc3, 0x61, + 0x8a, 0x86, 0x40, 0x2c, 0x11, 0xce, 0x0b, 0x28, 0x0a, 0x46, 0x2e, 0x2f, 0x60, + 0x46, 0xfe, 0x87, 0x58, 0xb6, 0x02, 0x07, 0xd9, 0x93, 0xb6, 0x9a, 0xa9, 0x8c, + 0xa1, 0x51, 0x8e, 0xe6, 0xf7, 0xa5, 0xe9, 0x23, 0xa5, 0x1e, 0x53, 0xbe, + ], + [ + 0xd2, 0xf3, 0x99, 0x3d, 0xe2, 0x0e, 0x79, 0xf7, 0x9c, 0xf3, 0x0e, 0x46, 0x09, + 0x14, 0xbc, 0xe9, 0x9f, 0x6f, 0x78, 0xab, + ], + [ + 0x0a, 0xce, 0xda, 0xbb, 0xdd, 0x56, 0x73, 0x22, 0x71, 0x11, 0xc2, 0xed, 0xf4, + 0x14, 0xb5, 0x47, 0xef, 0x17, 0x9d, 0x2b, 0x42, 0x83, 0x9c, 0xc1, 0x4d, 0x3a, + 0x12, 0x88, 0x83, 0x00, 0x0a, 0x6d, + ], + [ + 0x78, 0x56, 0xc6, 0xa6, 0xc8, 0xec, 0x80, 0x97, 0x13, 0xc4, 0xdd, 0x12, 0x13, + 0x5c, 0xbe, 0xf8, 0x61, 0x83, 0xfe, 0xd6, 0xc7, 0x7d, 0x92, 0x1e, 0xb5, 0x88, + 0x10, 0x1b, 0x6e, 0x4c, 0x15, 0x65, 0x86, 0xf5, 0x30, 0x50, 0x99, 0x52, 0xec, + 0x3b, 0x06, 0x3e, 0x0c, 0xf7, 0x98, 0x96, 0x98, 0xe5, + ], + [ + 0xd9, 0x03, 0x61, 0xeb, 0xb1, 0x1f, 0x9a, 0x6f, 0xac, 0x9b, 0x06, 0x83, 0xb2, + 0xe0, 0x0a, 0xc7, 0xe0, 0x4e, 0x35, 0x24, 0xa9, 0xfa, 0xcf, 0x91, 0xaa, 0x67, + 0x0b, 0xf4, 0x39, 0x72, 0x06, 0x6f, 0x31, 0xfb, 0x3a, 0x8e, 0xb6, 0xc0, 0xc1, + 0x32, 0x45, 0x0e, 0x95, 0xe6, 0x76, 0xff, 0x6f, 0x2d, 0x14, 0xa8, 0x41, 0xb1, + 0x6c, 0x62, 0xa0, 0x1d, 0x08, 0x21, 0x55, 0xfa, 0x70, 0xc2, 0xad, 0xa3, + ] + ), + test_case!( + [ + 0x61, 0x0c, 0x7d, 0x86, 0x5d, 0x4d, 0x99, 0x39, 0x8d, 0x5f, 0x8b, 0x22, 0x3b, + 0xac, 0x73, 0xd0, 0xb3, 0x22, 0x8e, 0x46, 0x05, 0xf9, 0xa2, 0xd9, 0x97, 0xfd, + 0x62, 0xff, 0x9f, 0x5b, 0x87, 0x80, 0x4d, 0x5c, 0x1e, 0x52, 0xdd, 0xbe, 0xa4, + 0x31, 0x7b, 0x65, 0x87, 0xa5, 0xde, 0x19, 0x35, 0x72, 0x82, 0x48, 0x1c, 0x3d, + ], + [ + 0x51, 0x15, 0xc7, 0xbe, 0x1c, 0x2d, 0x88, 0x8a, 0xe2, 0xf5, 0xd5, 0xf3, 0x1e, + 0x46, 0x3d, 0x21, 0x67, 0x43, 0xe3, 0xf2, + ], + [ + 0x5e, 0xdf, 0x62, 0x80, 0x40, 0xfe, 0xd0, 0xf3, 0x3a, 0xe0, 0x47, 0x0d, 0xac, + 0xd4, 0xba, 0x7a, 0x03, 0xa3, 0xbb, 0x7b, 0x62, 0xd8, 0xe5, 0x85, 0xdc, 0x33, + 0x7d, 0x52, 0xdd, 0x47, 0x79, 0x31, + ], + [ + 0x88, 0xb8, 0x6c, 0x4f, 0x55, 0xc9, 0x92, 0x2c, 0x9e, 0x49, 0x81, 0xfa, 0x0a, + 0x9f, 0x86, 0x45, 0xde, 0x17, 0x13, 0x48, 0x25, 0x3b, 0x23, 0x63, 0x19, 0xfe, + 0x1f, 0x0c, 0xd9, 0x22, 0x07, 0x0a, 0xa9, 0x65, 0x08, 0x8e, 0xd7, 0x38, 0x1a, + 0x07, 0xe4, 0xa8, 0x84, 0x28, 0x53, 0x8c, 0xae, 0x4d, + ], + [ + 0xa4, 0x3d, 0xa7, 0xcf, 0x66, 0xd6, 0xf8, 0xfc, 0xba, 0x52, 0xc9, 0xf8, 0x77, + 0xfc, 0xe8, 0x3b, 0xf2, 0xab, 0x3d, 0xc2, 0x05, 0x20, 0xdd, 0x88, 0xd9, 0x45, + 0x7d, 0xa1, 0x5f, 0x02, 0x45, 0x59, 0xcf, 0x1b, 0x97, 0xd4, 0x99, 0xcb, 0x93, + 0xe6, 0xbc, 0xa1, 0x34, 0xe6, 0x38, 0x04, 0x7b, 0x20, 0x0d, 0x52, 0x3d, 0xbc, + 0x8a, 0xa4, 0xd5, 0x36, 0x05, 0x70, 0xc2, 0x5a, 0xea, 0x09, 0x29, 0x54, + ] + ), + test_case!( + [ + 0xec, 0x74, 0x36, 0x9a, 0x3c, 0x0e, 0xd7, 0xd2, 0xff, 0x1e, 0x05, 0x1d, 0x15, + 0xa8, 0x9e, 0x29, 0x2b, 0x19, 0x03, 0x41, 0xe8, 0x22, 0x5a, 0xdf, 0x8a, 0xe5, + 0xdb, 0x1f, 0xe3, 0x85, 0xcf, 0x0e, 0x48, 0x6c, 0xbd, 0x37, 0x69, 0x8e, 0x20, + 0x46, 0xa2, 0x5b, 0xc9, 0xac, 0x2a, 0x0a, 0xed, 0xf8, 0x78, 0x88, 0xc5, 0x4f, + 0xf8, + ], + [ + 0x87, 0x01, 0x7f, 0x76, 0x59, 0xd1, 0xf4, 0xff, 0x53, 0x2f, 0x96, 0xae, 0x63, + 0x92, 0xfa, 0x8e, 0x2d, 0x88, 0xd1, 0x41, + ], + [ + 0xd4, 0xc7, 0x60, 0x1b, 0x89, 0x30, 0x31, 0x58, 0xa9, 0x14, 0x89, 0x42, 0x24, + 0x1f, 0xbd, 0x68, 0x32, 0xbb, 0x0b, 0x27, 0xd1, 0x4c, 0x6c, 0x53, 0xec, 0xd7, + 0xf5, 0x30, 0x51, 0xec, 0xa8, 0xa6, + ], + [ + 0x3c, 0x7f, 0x55, 0x0a, 0x9c, 0x30, 0xbc, 0x67, 0x33, 0x30, 0x86, 0xca, 0x67, + 0x79, 0xe4, 0xac, 0xd8, 0xe2, 0x79, 0xb8, 0xcb, 0x7c, 0x12, 0x99, 0x93, 0xb3, + 0x75, 0x4d, 0x8c, 0xca, 0xa5, 0x24, 0x13, 0x6f, 0x87, 0xe7, 0xe1, 0xcf, 0x3f, + 0xeb, 0x5f, 0x5f, 0x03, 0xee, 0xbe, 0xee, 0x80, 0xce, + ], + [ + 0x68, 0x1b, 0x4e, 0xb4, 0x22, 0x92, 0x2c, 0x01, 0xf1, 0x05, 0xf4, 0xc7, 0xcb, + 0x05, 0xef, 0x6c, 0x68, 0x89, 0x7e, 0x09, 0xc2, 0x14, 0xf2, 0x59, 0x12, 0x67, + 0x6e, 0x29, 0x13, 0xad, 0xeb, 0x10, 0x35, 0x16, 0x10, 0x8d, 0xaf, 0x9a, 0x3d, + 0xa6, 0x60, 0xed, 0x21, 0xa3, 0x19, 0xf4, 0xa8, 0x66, 0xfe, 0xdf, 0x5d, 0x30, + 0xbe, 0xa9, 0x6f, 0xc0, 0x8c, 0x0c, 0x87, 0xed, 0x90, 0x20, 0x3c, 0x47, + ] + ), + test_case!( + [ + 0x29, 0xca, 0x22, 0xbe, 0xf4, 0xe4, 0x52, 0x62, 0x90, 0xe1, 0xac, 0xcd, 0x4b, + 0x7c, 0x14, 0x75, 0xa6, 0x6a, 0x30, 0x13, 0xe6, 0x71, 0xf0, 0x32, 0xd9, 0x85, + 0xbd, 0x6a, 0x9a, 0xcf, 0x65, 0x16, 0xff, 0x42, 0x7c, 0x35, 0xca, 0x0d, 0x19, + 0xa9, 0x5b, 0x88, 0x3f, 0x99, 0xc4, 0x76, 0xbd, 0x97, 0x06, 0x6f, 0x50, 0x92, + 0x27, 0xc7, + ], + [ + 0x86, 0x5a, 0x7d, 0xb7, 0x49, 0x66, 0x63, 0x4a, 0x1c, 0xd3, 0xa2, 0xce, 0x90, + 0x3d, 0x26, 0x93, 0x25, 0x70, 0x67, 0x6a, + ], + [ + 0x7b, 0x72, 0xae, 0x69, 0xf5, 0x2f, 0xd0, 0xd1, 0x40, 0xdf, 0x57, 0x3b, 0xe0, + 0x47, 0xfd, 0xf9, 0xfd, 0x0d, 0xd0, 0xf1, 0x6d, 0x32, 0xcb, 0x3b, 0xd8, 0x38, + 0x90, 0xfe, 0x17, 0xcf, 0xa0, 0x70, + ], + [ + 0x35, 0x9f, 0x16, 0xcc, 0x64, 0x78, 0x4e, 0xb9, 0x2a, 0xe5, 0x9d, 0x6e, 0xb6, + 0x8f, 0xe3, 0x74, 0xb8, 0x8b, 0xc3, 0x0e, 0x42, 0xfd, 0x5f, 0x57, 0x57, 0x6d, + 0xf1, 0x9c, 0xb3, 0xe5, 0xfa, 0x0f, 0x53, 0x2d, 0x03, 0x2a, 0xea, 0x59, 0x21, + 0xe4, 0x3d, 0x76, 0x06, 0xb9, 0xa5, 0x9e, 0xe4, 0xee, + ], + [ + 0x7c, 0x95, 0x28, 0x3a, 0xf4, 0xe2, 0x34, 0xaf, 0x61, 0xa7, 0xf2, 0x12, 0xad, + 0xe6, 0x28, 0x8f, 0xb2, 0x76, 0x2b, 0x1c, 0xdb, 0xea, 0x90, 0x3c, 0x5a, 0x56, + 0x46, 0x93, 0x0d, 0xe8, 0x5d, 0x9f, 0x9a, 0x90, 0xd8, 0x8f, 0xd9, 0x10, 0xdf, + 0x02, 0x81, 0xfc, 0x8f, 0x8f, 0xb5, 0x8b, 0xd4, 0x61, 0xa0, 0x97, 0x69, 0x0e, + 0x4e, 0xef, 0x77, 0x47, 0xd3, 0x12, 0x6c, 0xa8, 0x45, 0x95, 0xd2, 0x51, + ] + ), + test_case!( + [ + 0x50, 0xca, 0xc8, 0x7a, 0x60, 0x00, 0x81, 0x01, 0x45, 0xef, 0x41, 0x14, 0x80, + 0x0c, 0x30, 0xcc, 0x2a, 0xf8, 0x98, 0xa3, 0x8e, 0x21, 0x46, 0x04, 0x99, 0xad, + 0xe2, 0x6a, 0x8e, 0xb3, 0x4b, 0xfa, 0x14, 0x55, 0x07, 0xba, 0x3b, 0x82, 0x6b, + 0x10, 0x88, 0x83, 0xd9, 0xe6, 0x59, 0x00, 0x19, 0xc3, 0xb6, 0x03, 0xaf, 0x36, + 0x0c, 0x7c, 0xf1, + ], + [ + 0x86, 0xbd, 0xc1, 0xb1, 0x4f, 0xa2, 0x22, 0x77, 0x67, 0x99, 0x10, 0x4c, 0x11, + 0x34, 0xf0, 0xbf, 0x9e, 0x24, 0x8b, 0x07, + ], + [ + 0xf5, 0xf3, 0x26, 0xf2, 0xb4, 0x56, 0x9c, 0xbe, 0x79, 0xce, 0xb3, 0x2a, 0x8f, + 0xa7, 0x4a, 0x94, 0x2b, 0xb6, 0x3d, 0x03, 0x97, 0xf4, 0xd9, 0xa7, 0x84, 0x7d, + 0x6a, 0xd2, 0x77, 0x58, 0xc1, 0x61, + ], + [ + 0x74, 0xc1, 0x48, 0x8f, 0x66, 0xa0, 0x31, 0x81, 0x6f, 0x9c, 0xf5, 0x2e, 0xf5, + 0xe2, 0x15, 0x88, 0x74, 0x9a, 0xec, 0xb0, 0x83, 0xa7, 0xaf, 0x2c, 0x2c, 0xc3, + 0xe0, 0x5a, 0x0f, 0xd3, 0xde, 0x5d, 0x52, 0xfc, 0x0c, 0x79, 0x51, 0x68, 0xe4, + 0xab, 0xea, 0x3a, 0x37, 0x98, 0x3e, 0xa7, 0x20, 0x4c, + ], + [ + 0x97, 0x94, 0x7d, 0xdc, 0x72, 0xd7, 0x3e, 0x46, 0x33, 0xaf, 0x91, 0xf2, 0x77, + 0xc3, 0xc4, 0xb4, 0x90, 0xfe, 0xd7, 0x51, 0xf0, 0xd0, 0x3b, 0x9b, 0x3f, 0x33, + 0xf4, 0x71, 0xe5, 0xb1, 0x7a, 0x2e, 0x9c, 0x12, 0x40, 0x8f, 0x2b, 0x3e, 0x04, + 0xac, 0x51, 0x38, 0xaa, 0x36, 0xcd, 0x34, 0x97, 0x49, 0x9f, 0xc3, 0x1f, 0x22, + 0xdb, 0x86, 0x3e, 0x43, 0x84, 0xa3, 0x90, 0x19, 0x37, 0x04, 0x53, 0x30, + ] + ), + test_case!( + [ + 0x20, 0xbc, 0x2a, 0xaf, 0xb9, 0x23, 0x16, 0x8f, 0x54, 0x8f, 0xd3, 0xc5, 0xd5, + 0xe2, 0xc2, 0xb0, 0xde, 0x68, 0x0e, 0xf0, 0xe5, 0xd9, 0x7d, 0xb7, 0x6b, 0xc5, + 0xc2, 0x0d, 0x65, 0xe6, 0x87, 0x96, 0x8d, 0xbc, 0xd0, 0x2f, 0x88, 0x6f, 0x21, + 0xaa, 0xcc, 0x20, 0xa0, 0x4a, 0x10, 0xc7, 0x80, 0x85, 0xb2, 0x1e, 0xe3, 0x24, + 0x58, 0x0c, 0xc0, 0x0b, + ], + [ + 0x64, 0xe5, 0x27, 0x82, 0xf5, 0xf1, 0x58, 0x51, 0xee, 0xe6, 0x1a, 0xa7, 0x73, + 0x3c, 0x84, 0x38, 0xdf, 0xaf, 0xf8, 0xd0, + ], + [ + 0x6e, 0x96, 0x3f, 0x78, 0x6d, 0x06, 0x98, 0xfb, 0x25, 0x9e, 0xcc, 0xdd, 0x59, + 0xd5, 0x9e, 0xe5, 0xbf, 0x47, 0x77, 0xbb, 0xbd, 0x9f, 0xe0, 0x5f, 0xe9, 0x48, + 0x4c, 0x90, 0xcc, 0x13, 0x06, 0x9c, + ], + [ + 0x2c, 0x59, 0xb4, 0x84, 0x6f, 0x41, 0xa3, 0x3c, 0xcd, 0xf5, 0x97, 0x79, 0xaa, + 0x5d, 0xfb, 0x5e, 0xaf, 0x97, 0x2f, 0xa1, 0xdb, 0xc6, 0x69, 0x7d, 0xf4, 0x6c, + 0xb7, 0xee, 0x5a, 0xd3, 0xff, 0x52, 0xbe, 0x01, 0xbc, 0x3e, 0xe7, 0x69, 0xc0, + 0xd4, 0xfe, 0xd2, 0xf2, 0x22, 0x53, 0xa1, 0xc1, 0x31, + ], + [ + 0x97, 0x02, 0x97, 0xd2, 0xd6, 0x68, 0x25, 0x7a, 0x06, 0x4f, 0x0e, 0xb5, 0xb2, + 0x70, 0xcf, 0x4d, 0x62, 0xc2, 0x87, 0xa1, 0x0d, 0xea, 0x8a, 0x28, 0x48, 0x7c, + 0x56, 0x9c, 0x10, 0xb1, 0x70, 0x33, 0xeb, 0x13, 0xda, 0xf7, 0x6c, 0xfc, 0x30, + 0xfa, 0x58, 0xfc, 0x7c, 0x2c, 0x8d, 0x5d, 0x3c, 0x5d, 0x9a, 0x0e, 0x5f, 0xa6, + 0x0c, 0x75, 0xf2, 0xad, 0x5a, 0x0b, 0xc8, 0xe3, 0x14, 0x4c, 0xbb, 0xed, + ] + ), + test_case!( + [ + 0x5f, 0xb2, 0x24, 0x70, 0xc4, 0xb6, 0x8b, 0x3e, 0xad, 0x17, 0x09, 0x72, 0x43, + 0x76, 0x26, 0x64, 0x03, 0xbd, 0xba, 0xd7, 0x2a, 0x1a, 0x36, 0x72, 0x70, 0xf3, + 0xff, 0xb7, 0xf5, 0x4e, 0x1a, 0x2d, 0x86, 0xdf, 0xac, 0x6e, 0x14, 0xe1, 0xbe, + 0xa4, 0x9c, 0x91, 0x21, 0x3d, 0x14, 0x69, 0x8b, 0xf4, 0x93, 0x2f, 0x13, 0x8c, + 0x7a, 0x7d, 0xf5, 0xf8, 0x0f, + ], + [ + 0x62, 0xe5, 0xa2, 0xbc, 0xb9, 0x1e, 0x86, 0xb4, 0x4e, 0x25, 0xb2, 0x49, 0x67, + 0x4f, 0xcd, 0x36, 0x24, 0x40, 0x76, 0xa2, + ], + [ + 0x64, 0x74, 0xbb, 0xb7, 0x8b, 0x45, 0x29, 0x20, 0xe4, 0x21, 0x31, 0xa3, 0x47, + 0x82, 0x5c, 0x94, 0xd4, 0x44, 0x7b, 0x6e, 0x8b, 0xb1, 0x84, 0x30, 0x5d, 0x96, + 0xc4, 0xb7, 0xa8, 0x3a, 0xa7, 0x91, + ], + [ + 0x27, 0x25, 0xb7, 0xff, 0x9d, 0x09, 0x11, 0x22, 0xdf, 0xf3, 0xf4, 0x57, 0x67, + 0xa3, 0x93, 0x86, 0xba, 0x15, 0x76, 0x89, 0x5f, 0xb0, 0x03, 0x42, 0xa6, 0x11, + 0x51, 0xa8, 0x4a, 0x9e, 0x86, 0xa0, 0x73, 0xe8, 0x3a, 0xd5, 0xed, 0xa0, 0x95, + 0x99, 0x43, 0xd9, 0x85, 0x72, 0xaf, 0xcb, 0x88, 0xaa, + ], + [ + 0xfb, 0x13, 0xfc, 0xf5, 0x7e, 0x63, 0xe4, 0xb7, 0x6a, 0x2f, 0xce, 0xcc, 0x0d, + 0xbf, 0x57, 0xc9, 0xf8, 0xc6, 0xab, 0x94, 0x8d, 0x66, 0xff, 0x40, 0x8b, 0x45, + 0x8e, 0x05, 0xdf, 0x6b, 0x3f, 0x60, 0x29, 0x83, 0x2b, 0xf4, 0x7a, 0x68, 0xcd, + 0x0f, 0x41, 0x59, 0x0a, 0x25, 0x84, 0x58, 0xe5, 0xec, 0xf1, 0xe9, 0x81, 0xbf, + 0x26, 0xa6, 0xd7, 0x91, 0x01, 0xe7, 0xa5, 0x9d, 0xdc, 0xc5, 0x21, 0x4f, + ] + ), + test_case!( + [ + 0xf6, 0x33, 0x42, 0x41, 0xf8, 0xc6, 0xb4, 0x60, 0x03, 0xab, 0xf8, 0xbc, 0x91, + 0x81, 0xd4, 0x3d, 0xee, 0x63, 0x6e, 0xc2, 0x22, 0xe2, 0x33, 0xd4, 0x65, 0xe5, + 0xde, 0x61, 0x2c, 0x70, 0xf7, 0x6e, 0x1d, 0x32, 0x12, 0xa1, 0x82, 0xd9, 0x2b, + 0x84, 0x48, 0x1b, 0xc5, 0x7a, 0x2b, 0xb4, 0x56, 0xd7, 0x4e, 0x56, 0x81, 0xc0, + 0x25, 0x64, 0xd1, 0xad, 0x25, 0x48, + ], + [ + 0xb7, 0x57, 0x56, 0x3a, 0x41, 0x55, 0x28, 0x19, 0xfb, 0x80, 0x3f, 0x52, 0x7b, + 0xa2, 0x05, 0x74, 0x3a, 0xaa, 0x0a, 0x21, + ], + [ + 0x34, 0x54, 0x22, 0xa3, 0xdf, 0xe0, 0xc1, 0x3d, 0x33, 0x48, 0xa9, 0x1e, 0x73, + 0xa8, 0xa4, 0xb0, 0x8c, 0x67, 0x59, 0xf7, 0x71, 0x64, 0xd7, 0xa2, 0x5b, 0xee, + 0x62, 0xbf, 0x09, 0x87, 0x42, 0xe5, + ], + [ + 0x57, 0xf2, 0x6e, 0x96, 0xc5, 0xac, 0x42, 0xed, 0x26, 0x54, 0xca, 0x94, 0xf6, + 0x26, 0x18, 0x1f, 0x5a, 0xa8, 0xe6, 0x24, 0x3a, 0xce, 0xf0, 0x46, 0x26, 0x20, + 0x2c, 0x81, 0x80, 0x1a, 0xdd, 0xaf, 0x62, 0x38, 0xda, 0xc3, 0x88, 0xab, 0xdb, + 0xbf, 0x55, 0xf2, 0x98, 0x31, 0xfa, 0x0a, 0x2a, 0xaf, + ], + [ + 0x53, 0x78, 0xd7, 0x87, 0xb3, 0xce, 0xd4, 0x05, 0xf3, 0x8a, 0x5c, 0xe2, 0x27, + 0x44, 0xd7, 0x99, 0xb1, 0x1d, 0x53, 0x6f, 0xde, 0x76, 0xe0, 0x24, 0xce, 0xd0, + 0x0a, 0xd4, 0x3f, 0x04, 0xe7, 0x79, 0xa0, 0xae, 0x8a, 0xd5, 0xdf, 0x21, 0xd5, + 0x8b, 0x9a, 0xaf, 0x31, 0xbc, 0x9c, 0xe6, 0x25, 0x44, 0xab, 0x89, 0xae, 0x50, + 0xd0, 0xab, 0x23, 0x4b, 0xbf, 0x0f, 0x81, 0x72, 0x06, 0x95, 0x38, 0xad, + ] + ), + test_case!( + [ + 0xa2, 0x36, 0x7a, 0x6e, 0xd0, 0x14, 0x71, 0xad, 0xb3, 0x36, 0x4b, 0xdb, 0x25, + 0xb2, 0xfe, 0x88, 0x53, 0x21, 0x43, 0xec, 0x0c, 0xc3, 0x69, 0x0b, 0xb7, 0xd8, + 0x41, 0x78, 0xd9, 0x97, 0x7c, 0x21, 0x44, 0x21, 0x40, 0xfe, 0x51, 0xba, 0x98, + 0x5a, 0x92, 0x7a, 0x54, 0x63, 0xca, 0x1a, 0x2b, 0x69, 0xbe, 0x16, 0x99, 0x8b, + 0x71, 0x2b, 0x4f, 0x18, 0xb4, 0xf2, 0x10, + ], + [ + 0xdc, 0x41, 0xf9, 0x2c, 0xf3, 0xee, 0xf1, 0xa1, 0x81, 0x14, 0x0c, 0xeb, 0x48, + 0xa5, 0x27, 0x32, 0xb7, 0x58, 0xef, 0xdb, + ], + [ + 0x6f, 0xa6, 0x84, 0x6f, 0x36, 0x78, 0x18, 0x77, 0xb0, 0x60, 0x31, 0x19, 0x61, + 0x6e, 0xd6, 0x2d, 0x46, 0x59, 0xbc, 0x50, 0xf7, 0x1d, 0x7a, 0x12, 0x5b, 0xb6, + 0xbc, 0x8b, 0xe8, 0x70, 0xba, 0x93, + ], + [ + 0x70, 0x0c, 0x87, 0xa8, 0xc2, 0xdf, 0xdf, 0x43, 0x55, 0x25, 0xd3, 0x95, 0x01, + 0x45, 0x20, 0x6a, 0x4c, 0xf2, 0x95, 0x69, 0x93, 0x59, 0x9c, 0x35, 0x7b, 0xea, + 0x22, 0x81, 0x85, 0x41, 0xff, 0xa9, 0xcd, 0x2d, 0xbe, 0xd2, 0x82, 0x41, 0x0b, + 0x08, 0x3c, 0xca, 0x8e, 0x18, 0xcd, 0x48, 0x27, 0x3f, + ], + [ + 0x44, 0xd2, 0xc1, 0x58, 0xd8, 0x7e, 0xbb, 0x23, 0x44, 0xe7, 0x0e, 0x4f, 0xe2, + 0x7c, 0xa8, 0x55, 0xca, 0xc6, 0x94, 0x61, 0xbb, 0x4f, 0x38, 0x29, 0x54, 0x1c, + 0x01, 0x0f, 0xe3, 0xa9, 0x4a, 0xa7, 0x11, 0xb2, 0xe9, 0x59, 0xae, 0x1b, 0x83, + 0x13, 0xf3, 0x47, 0xce, 0xe8, 0xc4, 0x24, 0xc1, 0x3e, 0x12, 0x79, 0x4a, 0x6c, + 0x27, 0x9e, 0xb7, 0xe1, 0xc7, 0x13, 0x4d, 0xf5, 0x70, 0x0e, 0x32, 0x1e, + ] + ), + test_case!( + [ + 0xa8, 0x58, 0x76, 0x2a, 0x62, 0xa3, 0x3a, 0xf3, 0x49, 0x3f, 0x6a, 0x55, 0x81, + 0xfa, 0x2c, 0x81, 0xb3, 0xac, 0x1c, 0xa0, 0x19, 0x1b, 0x2f, 0x8d, 0x54, 0xa4, + 0x7a, 0x7a, 0xa0, 0xea, 0x3b, 0x27, 0xde, 0x8b, 0xf4, 0xef, 0x1f, 0xee, 0xb2, + 0x12, 0xa0, 0x31, 0x8f, 0xba, 0x26, 0xdf, 0xbf, 0xa4, 0x08, 0x44, 0x65, 0x52, + 0x56, 0x1d, 0xcf, 0xf2, 0x4e, 0x32, 0x1a, 0x2a, + ], + [ + 0xb6, 0xfb, 0x3e, 0xf4, 0x66, 0x67, 0x09, 0xcb, 0x77, 0x77, 0x01, 0xb8, 0x7b, + 0x82, 0x45, 0x67, 0x13, 0x31, 0x48, 0xe2, + ], + [ + 0x71, 0x90, 0x7c, 0x71, 0x9c, 0x32, 0x30, 0x9d, 0x31, 0x08, 0x1c, 0x6f, 0x9a, + 0x9a, 0x2d, 0xe5, 0x6e, 0xca, 0x4d, 0xca, 0x8c, 0xdf, 0x44, 0xc3, 0x2f, 0x4a, + 0x51, 0xc6, 0xb8, 0xff, 0x7e, 0xc5, + ], + [ + 0xdf, 0x3e, 0x25, 0x42, 0x7a, 0xdf, 0x93, 0xfc, 0xca, 0x5a, 0x5c, 0x1e, 0x13, + 0x67, 0x82, 0xa2, 0x1b, 0xe4, 0x7c, 0x65, 0xd4, 0xbd, 0xa8, 0x69, 0x5d, 0xbe, + 0xd1, 0x2a, 0x2a, 0x1f, 0x14, 0xf8, 0xb1, 0x48, 0x63, 0xd3, 0x7d, 0x4f, 0x7c, + 0x75, 0x32, 0x57, 0x30, 0x03, 0x9e, 0x4b, 0x1a, 0x82, + ], + [ + 0x67, 0x91, 0x7f, 0xa9, 0x0f, 0x7f, 0x97, 0xfd, 0xb1, 0x4e, 0x1b, 0x9e, 0xb0, + 0x8a, 0xe1, 0x99, 0xa5, 0x63, 0x3d, 0xbf, 0xf6, 0xa5, 0x1e, 0xa7, 0xfc, 0x78, + 0x68, 0x7a, 0x61, 0x76, 0xe1, 0xe5, 0x70, 0xc0, 0x3f, 0xf6, 0x20, 0x7e, 0xa4, + 0xfb, 0x66, 0x20, 0xb0, 0xe1, 0x96, 0xe2, 0xc2, 0x86, 0xf5, 0xf6, 0x8a, 0x8b, + 0xe2, 0xdf, 0x80, 0xc8, 0x2d, 0x61, 0x31, 0x11, 0xdc, 0x76, 0xb8, 0x8a, + ] + ), + test_case!( + [ + 0x90, 0xc0, 0xec, 0x8d, 0x9d, 0x67, 0x58, 0x2a, 0xcd, 0x3d, 0x35, 0xd6, 0xc8, + 0x14, 0xc4, 0x51, 0x97, 0xe2, 0x04, 0x6d, 0xb3, 0xa1, 0xa9, 0xc1, 0x11, 0xac, + 0x28, 0xf3, 0xd3, 0xa7, 0x0e, 0xac, 0xc7, 0xb6, 0x2a, 0xa1, 0x82, 0x12, 0x68, + 0xf5, 0x55, 0x1a, 0x16, 0xbb, 0xa3, 0xfe, 0x9a, 0x59, 0x5c, 0x15, 0x01, 0xca, + 0x59, 0xb1, 0x23, 0x89, 0xce, 0x20, 0x17, 0x91, 0xd1, + ], + [ + 0x2d, 0xa7, 0x9e, 0x20, 0x76, 0x0c, 0x76, 0x51, 0x16, 0x6c, 0x12, 0x99, 0xd0, + 0xcc, 0x49, 0x35, 0x32, 0xb2, 0x64, 0xde, + ], + [ + 0x31, 0x39, 0xa5, 0x31, 0xa9, 0xa4, 0xc0, 0xce, 0x67, 0x57, 0x6f, 0x64, 0x6e, + 0x49, 0x07, 0xf6, 0x4a, 0x73, 0x9e, 0xfb, 0x98, 0xba, 0x73, 0x4f, 0x2c, 0x48, + 0x98, 0x88, 0xb8, 0x1a, 0xb0, 0x75, + ], + [ + 0xe1, 0xe1, 0x4c, 0xaa, 0x5a, 0x1a, 0xdd, 0xc4, 0x7f, 0x42, 0xa9, 0x4c, 0xf0, + 0xef, 0xe4, 0x08, 0x8b, 0xdd, 0x4d, 0xce, 0x3a, 0xac, 0x38, 0x7d, 0x6d, 0xdd, + 0x52, 0x1c, 0x8b, 0x69, 0x30, 0x92, 0x78, 0xd7, 0x64, 0x15, 0x3a, 0x5f, 0x35, + 0xc7, 0x3e, 0x85, 0x45, 0x65, 0x25, 0x49, 0xf3, 0x67, + ], + [ + 0x02, 0x87, 0x8d, 0xb1, 0x16, 0xc5, 0x03, 0xcf, 0xb4, 0xfe, 0x0d, 0xb8, 0x96, + 0xfd, 0xbb, 0xa7, 0x29, 0x7f, 0x82, 0x95, 0xf7, 0xa0, 0x31, 0xf5, 0xb8, 0x7b, + 0x2f, 0x4d, 0x99, 0x2f, 0x65, 0x33, 0x0a, 0x33, 0x79, 0x52, 0xc6, 0x1a, 0xdb, + 0x3c, 0x3b, 0xa9, 0x50, 0x09, 0x38, 0x59, 0xc5, 0x98, 0xb4, 0xa4, 0x3a, 0x79, + 0x01, 0x41, 0xb5, 0xf5, 0x08, 0x91, 0xf2, 0x66, 0xdf, 0x40, 0x34, 0x60, + ] + ), + test_case!( + [ + 0xdd, 0x85, 0xa8, 0x2e, 0x98, 0x6d, 0x1d, 0x87, 0x67, 0x99, 0xef, 0x88, 0x22, + 0xc6, 0xc9, 0xc4, 0x49, 0x8e, 0x62, 0x44, 0x25, 0xa9, 0x1a, 0x86, 0x8a, 0xaa, + 0x98, 0x38, 0x87, 0xab, 0x1d, 0xa1, 0xed, 0x14, 0x24, 0x41, 0x42, 0xc6, 0xf3, + 0xbc, 0x76, 0xe2, 0xf4, 0xe5, 0x60, 0x10, 0x48, 0xf6, 0x60, 0x42, 0x10, 0x05, + 0x05, 0xc5, 0x46, 0x35, 0x5d, 0xdf, 0x9f, 0x34, 0xaa, 0xc2, + ], + [ + 0xdc, 0xb2, 0xb7, 0xcd, 0x3b, 0xde, 0x26, 0x77, 0x87, 0x0c, 0x35, 0x1f, 0xb7, + 0x46, 0xe9, 0x19, 0x75, 0x04, 0x5a, 0x6e, + ], + [ + 0x2b, 0x46, 0xed, 0xca, 0x75, 0x25, 0xc0, 0x8c, 0xce, 0xaa, 0x09, 0x4c, 0xf6, + 0xe1, 0x21, 0x7a, 0x5e, 0xca, 0x96, 0x57, 0xf8, 0xf0, 0x7f, 0x2f, 0x36, 0xde, + 0xeb, 0xc6, 0x96, 0x83, 0x07, 0x33, + ], + [ + 0x26, 0xe0, 0x7b, 0x3e, 0xc4, 0xb7, 0xe9, 0x69, 0xb9, 0x38, 0x53, 0x54, 0x67, + 0x78, 0xe5, 0x85, 0x54, 0xaa, 0x15, 0x96, 0xc4, 0xe1, 0xbc, 0xb6, 0x89, 0x27, + 0xb6, 0x12, 0xf8, 0x61, 0xe0, 0x25, 0xa0, 0xf0, 0x03, 0x4e, 0xaa, 0xa3, 0xc0, + 0xf4, 0xa0, 0x7a, 0x6e, 0x89, 0xb0, 0xff, 0x83, 0xa3, + ], + [ + 0x30, 0xe8, 0xf4, 0xc5, 0x66, 0xd5, 0xb8, 0x51, 0x92, 0x2e, 0xb4, 0x88, 0x04, + 0xff, 0xb4, 0xf2, 0x2f, 0xf6, 0xc6, 0x67, 0xe0, 0x01, 0x0e, 0xa9, 0x44, 0x6e, + 0x7e, 0xe7, 0x75, 0x8d, 0x46, 0xb8, 0x59, 0x50, 0xec, 0x74, 0x3e, 0x70, 0x43, + 0x41, 0xb1, 0xa5, 0x2e, 0xfa, 0x66, 0xe9, 0xba, 0x4e, 0xda, 0x01, 0x6d, 0x77, + 0x88, 0x53, 0xb8, 0xc5, 0xaa, 0xd1, 0xe0, 0x50, 0xa3, 0xb9, 0x16, 0x87, + ] + ), + test_case!( + [ + 0x3c, 0x02, 0xd2, 0xb6, 0x75, 0x66, 0x8a, 0xb4, 0x94, 0x3a, 0x75, 0xb0, 0x80, + 0xda, 0x20, 0x47, 0x47, 0x02, 0xdb, 0xf5, 0xf0, 0xbd, 0x54, 0xc8, 0x54, 0x93, + 0xcf, 0x91, 0x29, 0xba, 0x63, 0xde, 0xd2, 0xc9, 0xb3, 0x78, 0x13, 0xae, 0x92, + 0xc2, 0xe7, 0xb0, 0xca, 0xac, 0x6a, 0x07, 0xb9, 0xf2, 0x92, 0x2d, 0x4c, 0xef, + 0xc7, 0xd3, 0x4b, 0x1a, 0x63, 0x44, 0xe8, 0x35, 0x19, 0xb7, 0x13, + ], + [ + 0x83, 0xd4, 0xd8, 0x4b, 0x9c, 0x88, 0xdd, 0xf5, 0xed, 0x07, 0x04, 0x23, 0xc0, + 0x4b, 0x44, 0x0d, 0x12, 0x1d, 0x89, 0xd9, + ], + [ + 0x0a, 0x45, 0xb7, 0xe1, 0xcb, 0xfd, 0x9f, 0xb7, 0xbb, 0x82, 0xa4, 0x57, 0xf4, + 0x44, 0x83, 0x2b, 0x2a, 0x74, 0x81, 0x5e, 0x31, 0x36, 0xe4, 0x2c, 0x53, 0xae, + 0xdc, 0x52, 0x65, 0x29, 0x7c, 0x7e, + ], + [ + 0x4f, 0xe1, 0x70, 0x48, 0x52, 0xc0, 0x54, 0xda, 0xac, 0x7f, 0xaf, 0x90, 0x9a, + 0x1b, 0xb7, 0x33, 0x93, 0xbb, 0xa5, 0x5d, 0xb2, 0x4f, 0xd0, 0x04, 0x13, 0x8d, + 0x9f, 0x77, 0xc9, 0xaa, 0xb3, 0x2f, 0xb7, 0xcb, 0x8e, 0x1d, 0xa1, 0xd4, 0xaf, + 0x44, 0x70, 0xb3, 0xa2, 0xd9, 0xfd, 0xf6, 0xcd, 0x4a, + ], + [ + 0x95, 0x75, 0x49, 0x7a, 0xfc, 0x34, 0x68, 0xde, 0x7f, 0x35, 0x8f, 0x49, 0x30, + 0x3a, 0x1b, 0x8e, 0xb4, 0x2e, 0xaa, 0x04, 0xe7, 0x2b, 0xf7, 0x81, 0x56, 0x5a, + 0xbf, 0xd9, 0xa8, 0xe0, 0xf7, 0xd1, 0x66, 0x50, 0x9b, 0x05, 0xdb, 0x6c, 0x64, + 0xb3, 0xc6, 0xb7, 0x7d, 0x63, 0xfb, 0x4c, 0xb0, 0xeb, 0x44, 0xb3, 0x20, 0x5a, + 0x63, 0xf0, 0x52, 0xa1, 0x76, 0x29, 0xa8, 0x69, 0xbd, 0xf3, 0x66, 0xed, + ] + ), + test_case!( + [ + 0x12, 0x1e, 0x67, 0xda, 0x20, 0x99, 0xdb, 0x3d, 0xeb, 0xd0, 0xee, 0xab, 0x37, + 0x41, 0x25, 0xbe, 0x63, 0x69, 0x87, 0xe1, 0x19, 0x3a, 0x90, 0xd4, 0xb7, 0x59, + 0xe4, 0x6b, 0xc0, 0xc9, 0xe2, 0xa9, 0x54, 0x18, 0xd1, 0x9c, 0xae, 0x4b, 0x56, + 0xa0, 0x24, 0xb4, 0x05, 0x20, 0x74, 0xcb, 0x5d, 0x4a, 0x4e, 0x2a, 0x53, 0xf1, + 0x8a, 0x33, 0x19, 0xa0, 0x82, 0x6e, 0xfb, 0xaf, 0xda, 0x9a, 0xa2, 0x4f, + ], + [ + 0xd5, 0x3d, 0xcb, 0xb6, 0xd2, 0x42, 0x50, 0xd0, 0x23, 0xf1, 0x98, 0xac, 0x78, + 0x3f, 0x5e, 0x9b, 0x7f, 0x87, 0x9c, 0x6b, + ], + [ + 0xdc, 0xa2, 0x04, 0x22, 0xd0, 0x32, 0x08, 0x2b, 0xc5, 0x22, 0x78, 0xba, 0xfd, + 0x6e, 0x81, 0xb8, 0x74, 0x68, 0xe3, 0xa1, 0x12, 0x9e, 0xd4, 0x50, 0x6b, 0xc3, + 0x1e, 0xf6, 0x8f, 0xcb, 0x7c, 0xa0, + ], + [ + 0xa4, 0xfb, 0x1f, 0xb7, 0xa0, 0xfa, 0xcf, 0xa5, 0x2c, 0x9b, 0x49, 0xc8, 0xd8, + 0x0b, 0x3c, 0xa9, 0xca, 0xbc, 0x34, 0x83, 0xae, 0x1f, 0x3c, 0xc7, 0x00, 0x89, + 0x67, 0x35, 0x18, 0x9f, 0x06, 0xf8, 0x94, 0xf9, 0x7a, 0x85, 0x28, 0xa6, 0x4e, + 0xca, 0xc5, 0x2d, 0xbd, 0xd9, 0x7d, 0x95, 0xa3, 0x8b, + ], + [ + 0x0d, 0x3a, 0x84, 0x73, 0xfb, 0xe7, 0x94, 0x0f, 0x91, 0x69, 0xd1, 0x37, 0x4c, + 0x43, 0x95, 0xa6, 0x8f, 0xbf, 0xf0, 0xfb, 0x40, 0x75, 0x52, 0x15, 0x7f, 0xef, + 0xe8, 0xa6, 0x26, 0x0c, 0x57, 0xe7, 0x3b, 0x37, 0x93, 0xe1, 0x11, 0x07, 0x96, + 0xc5, 0x8f, 0x9d, 0x3b, 0x81, 0x99, 0x70, 0xa4, 0x3a, 0x0c, 0x04, 0x94, 0x2b, + 0xca, 0xa8, 0xf8, 0x6a, 0x04, 0x6b, 0x52, 0x1c, 0xa6, 0x08, 0xca, 0x2e, + ] + ), + test_case!( + [ + 0x92, 0x83, 0x41, 0xf1, 0x03, 0x26, 0x34, 0xb6, 0xf2, 0x68, 0xb3, 0x55, 0x51, + 0x06, 0xb1, 0x62, 0x42, 0xae, 0x66, 0x9c, 0xae, 0xf4, 0x62, 0xcb, 0x97, 0xe5, + 0xd8, 0xdc, 0x40, 0x29, 0x00, 0x3d, 0x1c, 0x43, 0xf9, 0xa7, 0x51, 0xd0, 0x75, + 0x95, 0x53, 0xb9, 0xc8, 0xe6, 0x87, 0xa8, 0x2f, 0x52, 0xf9, 0xf0, 0x1d, 0xa8, + 0x14, 0xbc, 0x99, 0xe1, 0x59, 0x44, 0x7b, 0x85, 0x38, 0x0c, 0xa0, 0x64, 0x20, + ], + [ + 0x36, 0x36, 0xbf, 0xeb, 0x6a, 0x32, 0xbc, 0x28, 0xc9, 0xa6, 0x60, 0x0c, 0x9d, + 0x7b, 0xab, 0x5e, 0x9b, 0xb3, 0x7b, 0xd5, + ], + [ + 0x05, 0x4f, 0xab, 0xe6, 0xec, 0x76, 0xc2, 0xff, 0x2e, 0x8a, 0xdc, 0xd7, 0xc8, + 0x49, 0x01, 0x19, 0xef, 0x04, 0xe7, 0x2f, 0x1e, 0xea, 0x55, 0x74, 0x54, 0x27, + 0x79, 0xf8, 0xd5, 0x34, 0xba, 0xb8, + ], + [ + 0xef, 0x4e, 0x7b, 0xa7, 0x5f, 0xe2, 0x64, 0x04, 0xaa, 0x3e, 0xce, 0x0a, 0xe7, + 0xb2, 0x09, 0x84, 0xba, 0x9a, 0x85, 0xb1, 0x9e, 0x3d, 0x05, 0x4a, 0x4a, 0x6d, + 0xdc, 0xb8, 0x73, 0xad, 0x31, 0x19, 0x73, 0xa1, 0x36, 0x29, 0x9a, 0x2c, 0x62, + 0xb5, 0xef, 0x31, 0xe5, 0x39, 0xd4, 0x27, 0x55, 0x98, + ], + [ + 0x6a, 0x7c, 0xcf, 0x12, 0x78, 0x7a, 0xcc, 0xfd, 0xb6, 0xc2, 0x47, 0xe7, 0x68, + 0x61, 0x53, 0xf8, 0xb3, 0xe6, 0x3d, 0x97, 0x13, 0x27, 0x49, 0x83, 0x15, 0x18, + 0xb8, 0x0d, 0x2b, 0x45, 0xd0, 0xe1, 0xfe, 0xb5, 0xfd, 0xad, 0x6a, 0x5d, 0x4b, + 0x4b, 0xc8, 0x49, 0x86, 0x8a, 0xbb, 0x80, 0x20, 0x68, 0xd9, 0x3d, 0xcd, 0xa0, + 0x8a, 0x59, 0x97, 0x43, 0x03, 0x1b, 0xbc, 0x04, 0xf2, 0xfb, 0x80, 0x6f, + ] + ), + test_case!( + [ + 0x0b, 0xe1, 0x8e, 0xc9, 0xc7, 0x69, 0x83, 0x97, 0x95, 0x8f, 0x9e, 0x93, 0x90, + 0xd8, 0xbe, 0xd1, 0x79, 0xdc, 0x12, 0x9c, 0x8d, 0xd5, 0xf7, 0x6f, 0xf1, 0x96, + 0x18, 0xbd, 0x4e, 0x92, 0xe5, 0xfe, 0x15, 0x85, 0xfc, 0xa8, 0x5d, 0x16, 0x3b, + 0x48, 0x1f, 0x80, 0x1e, 0x38, 0x7e, 0x3c, 0x00, 0x0a, 0xc2, 0x09, 0xc0, 0xf0, + 0x95, 0x51, 0xe0, 0x39, 0x8b, 0x49, 0x9f, 0x8e, 0x0a, 0x3a, 0xf4, 0xc4, 0xda, + 0xa5, + ], + [ + 0xc6, 0xb0, 0x83, 0x31, 0x92, 0xa7, 0xc3, 0xff, 0x9b, 0xdb, 0xfa, 0xa9, 0x83, + 0x2a, 0x0d, 0xd4, 0x9c, 0x70, 0xbe, 0x73, + ], + [ + 0xa1, 0xfd, 0x84, 0xbf, 0xb5, 0x9f, 0x2f, 0x2c, 0x20, 0x9b, 0x2d, 0x95, 0x71, + 0x10, 0x9c, 0x9f, 0xe9, 0x0a, 0xe3, 0xa6, 0x81, 0x08, 0xf6, 0x74, 0xdb, 0x7f, + 0x23, 0x78, 0x5b, 0x2a, 0x46, 0xab, + ], + [ + 0xfe, 0x11, 0xa9, 0x95, 0xe0, 0x54, 0x34, 0x6f, 0xc8, 0x13, 0xe3, 0x29, 0xcf, + 0x68, 0x56, 0x34, 0x19, 0x1d, 0xe1, 0xa4, 0xda, 0x58, 0x0f, 0xc2, 0x67, 0xf2, + 0x89, 0x5f, 0x93, 0x3f, 0x74, 0x1c, 0x4d, 0xe9, 0x03, 0xd8, 0xee, 0xf6, 0x13, + 0x0a, 0x8e, 0x93, 0x20, 0x11, 0x53, 0x9f, 0x8e, 0xdb, + ], + [ + 0xc4, 0xf6, 0xc2, 0xd4, 0x41, 0x4b, 0xd9, 0xee, 0x97, 0xa3, 0x98, 0x49, 0xd0, + 0x1d, 0xbd, 0x8c, 0x0d, 0x39, 0x1b, 0xc9, 0x67, 0x35, 0x4b, 0xae, 0xb4, 0xd6, + 0x5e, 0x1c, 0x0b, 0xbc, 0x5a, 0x81, 0x4a, 0x61, 0x3d, 0x4d, 0xcd, 0xe5, 0xf1, + 0x7b, 0x87, 0x7a, 0x49, 0xa3, 0x2d, 0x02, 0x5f, 0xfe, 0xf6, 0x8d, 0x51, 0x99, + 0x9b, 0x66, 0x13, 0xdb, 0x9a, 0x3f, 0xf9, 0xc8, 0xb7, 0x45, 0x03, 0x0e, + ] + ), + test_case!( + [ + 0xc3, 0x78, 0xc0, 0x93, 0x25, 0x94, 0x37, 0xfa, 0x21, 0x99, 0xb0, 0xbb, 0xa1, + 0xe9, 0x8d, 0xcb, 0x76, 0x4a, 0x71, 0x3c, 0xa9, 0x07, 0x6c, 0xe7, 0x20, 0x6c, + 0xeb, 0xe7, 0xb9, 0x27, 0x4a, 0x48, 0x55, 0x98, 0x2e, 0xba, 0x27, 0x88, 0x65, + 0x30, 0xbf, 0x08, 0xc6, 0x17, 0x26, 0x00, 0x9b, 0x22, 0xa2, 0xf8, 0xfb, 0x2f, + 0xdc, 0x1a, 0xf1, 0x05, 0x1e, 0x45, 0x4e, 0x2c, 0xf5, 0xaa, 0x52, 0xb0, 0xda, + 0xa4, 0x15, + ], + [ + 0x56, 0xc5, 0x36, 0xa2, 0x8f, 0xa3, 0x20, 0x78, 0x4f, 0x3e, 0x4b, 0x14, 0x59, + 0x0c, 0x5e, 0x63, 0x52, 0xb9, 0xe6, 0xed, + ], + [ + 0x24, 0x2b, 0xb2, 0xb4, 0xa1, 0xd7, 0xd9, 0x83, 0x26, 0xfe, 0x43, 0x50, 0x3d, + 0xbe, 0x1d, 0x35, 0x0d, 0x7b, 0xae, 0x34, 0xb8, 0xc9, 0xd9, 0x62, 0x4f, 0x2b, + 0xf3, 0x2c, 0x5e, 0x28, 0xa4, 0xc3, + ], + [ + 0x83, 0x74, 0xd4, 0x7b, 0x2a, 0x99, 0xde, 0x70, 0xa5, 0x7f, 0x86, 0x11, 0xb5, + 0x09, 0x65, 0x54, 0x9e, 0x2b, 0x48, 0x73, 0x9e, 0xa6, 0xe1, 0xb9, 0x2e, 0x67, + 0x9d, 0xb9, 0x9f, 0x64, 0x14, 0x0b, 0x72, 0x6d, 0xf7, 0x32, 0x66, 0x7d, 0xac, + 0xb1, 0xba, 0x10, 0xd9, 0xf3, 0xd5, 0xfa, 0x9e, 0xb8, + ], + [ + 0xab, 0xdd, 0xbd, 0x1b, 0xa7, 0x21, 0x15, 0x3a, 0xe8, 0xc7, 0x76, 0x96, 0x01, + 0xf2, 0x0b, 0x4b, 0x4d, 0xef, 0xf3, 0x38, 0x7a, 0x7b, 0xd0, 0x9f, 0xeb, 0x3a, + 0x84, 0x59, 0xd8, 0xf2, 0xda, 0xf2, 0xbe, 0xb7, 0x9e, 0x37, 0x34, 0x1d, 0xa9, + 0x4d, 0xab, 0x49, 0xda, 0xbb, 0xe4, 0x84, 0x29, 0x71, 0xda, 0x1b, 0x38, 0x54, + 0x76, 0x3f, 0x34, 0xd5, 0xf3, 0xe9, 0xcc, 0xb3, 0xd2, 0x93, 0x2c, 0x59, + ] + ), + test_case!( + [ + 0x9b, 0xc2, 0x33, 0xd0, 0x2e, 0x1f, 0xd0, 0xe4, 0x9d, 0x54, 0x97, 0x15, 0x1a, + 0x7e, 0xd7, 0xb3, 0x90, 0x8a, 0x99, 0x4e, 0x81, 0x66, 0xe4, 0xcd, 0x42, 0x63, + 0x6b, 0x52, 0x27, 0xb5, 0x6c, 0x9b, 0x2a, 0x75, 0xd8, 0x2d, 0x23, 0xbd, 0x00, + 0xff, 0x1e, 0x89, 0x9e, 0xc9, 0x56, 0xc4, 0xa4, 0x16, 0xa4, 0x60, 0xd9, 0x84, + 0xc9, 0xae, 0xb3, 0x2c, 0xb4, 0xd8, 0x00, 0x53, 0x5f, 0x25, 0x45, 0x74, 0x0b, + 0x2c, 0x7f, 0x94, + ], + [ + 0x42, 0xd5, 0xe6, 0x08, 0xe5, 0xa1, 0x03, 0x8c, 0x89, 0x3b, 0x4f, 0x03, 0x14, + 0x7f, 0x2a, 0x03, 0xa0, 0xf2, 0x9b, 0x4f, + ], + [ + 0xb9, 0x74, 0x1b, 0x8f, 0x66, 0xee, 0xe2, 0x74, 0xc5, 0x71, 0xe1, 0xfe, 0xac, + 0x2f, 0x8c, 0xb7, 0xb2, 0x52, 0xde, 0xf2, 0x08, 0x96, 0x00, 0xcd, 0x59, 0xec, + 0x67, 0x29, 0x1f, 0xd1, 0x99, 0xef, + ], + [ + 0xf3, 0x02, 0x5e, 0x4c, 0x64, 0x23, 0xab, 0xaa, 0x0e, 0xa8, 0xbc, 0xa4, 0x3f, + 0x48, 0x05, 0x5c, 0xca, 0x5e, 0xe2, 0xb5, 0x82, 0x68, 0x2c, 0xf4, 0xae, 0xd2, + 0xaf, 0xe3, 0x73, 0xbc, 0xe7, 0xb7, 0x7a, 0x07, 0x60, 0xc0, 0x12, 0x39, 0x49, + 0x61, 0x63, 0x4f, 0x6d, 0xc0, 0x4a, 0x3e, 0xf2, 0xf8, + ], + [ + 0xc5, 0x74, 0xc4, 0x4f, 0x2e, 0xf8, 0xd8, 0x37, 0x70, 0x9a, 0x10, 0x31, 0x8e, + 0xc6, 0x0e, 0xb0, 0xa5, 0x97, 0xbf, 0xd6, 0xa1, 0xe8, 0xb1, 0x57, 0xbb, 0x81, + 0x98, 0x0d, 0x56, 0x00, 0x29, 0xd8, 0xc1, 0x3a, 0x21, 0xa4, 0xbd, 0x15, 0x12, + 0xf8, 0x4a, 0x94, 0x8c, 0x38, 0x17, 0x15, 0x54, 0xbe, 0x4b, 0x98, 0x3a, 0x5b, + 0x1d, 0xc0, 0x52, 0x76, 0xae, 0x68, 0x14, 0xd5, 0xfc, 0x2d, 0xd0, 0x10, + ] + ), + test_case!( + [ + 0x47, 0xd5, 0x60, 0x14, 0x8b, 0xe6, 0x2e, 0x40, 0x14, 0xf8, 0xa1, 0x37, 0x46, + 0xa6, 0x79, 0xde, 0x4c, 0x60, 0xdd, 0xdd, 0x17, 0xc5, 0x6d, 0x29, 0x8c, 0xf6, + 0x9b, 0x63, 0xf3, 0xee, 0x02, 0xce, 0xe0, 0x5a, 0x5d, 0xb5, 0x94, 0x42, 0xa2, + 0x3c, 0x12, 0x19, 0xa4, 0xfa, 0x4d, 0xe3, 0x2d, 0x75, 0xd8, 0x2b, 0x9e, 0x2e, + 0x8e, 0x91, 0xca, 0xbb, 0x42, 0x14, 0xd7, 0x84, 0x9e, 0x4a, 0xfe, 0x67, 0xa2, + 0xf1, 0x98, 0xd0, 0x2c, + ], + [ + 0x52, 0xe0, 0x5e, 0x83, 0x26, 0xb5, 0x87, 0x8f, 0xb0, 0x86, 0x1e, 0x7f, 0x34, + 0x42, 0x11, 0x39, 0x72, 0x4a, 0x7f, 0x03, + ], + [ + 0x09, 0x0d, 0x0d, 0x4d, 0x3c, 0x58, 0xe4, 0x97, 0x11, 0x22, 0x17, 0x4a, 0xf8, + 0x57, 0xaf, 0x6c, 0xb0, 0x5f, 0xff, 0x63, 0x9c, 0xf3, 0xf1, 0xd1, 0x8b, 0x83, + 0xb1, 0x77, 0x84, 0xe9, 0x68, 0x86, + ], + [ + 0x94, 0x59, 0xe5, 0x9d, 0x7a, 0xb8, 0x45, 0x18, 0xe1, 0x76, 0x72, 0x71, 0x06, + 0xf9, 0x82, 0x1b, 0xd5, 0xcf, 0x27, 0x0a, 0x8b, 0x39, 0x3e, 0xac, 0x70, 0xd7, + 0xb3, 0xcf, 0x2a, 0xc9, 0x63, 0x0a, 0x67, 0x8f, 0xc1, 0x10, 0x80, 0x7f, 0x98, + 0x01, 0x4d, 0xfe, 0xe9, 0x16, 0x24, 0xbb, 0x7a, 0xb8, + ], + [ + 0xab, 0xfd, 0xc8, 0xf4, 0x57, 0xfb, 0xd2, 0x87, 0xe8, 0x59, 0xec, 0x9a, 0x30, + 0x46, 0x87, 0x17, 0x86, 0x19, 0xd7, 0x3b, 0xf8, 0x34, 0x15, 0x9a, 0x92, 0x92, + 0x66, 0x5f, 0x2e, 0x56, 0x4c, 0xbd, 0xf0, 0x9e, 0x14, 0x78, 0x55, 0x93, 0x0c, + 0x5a, 0x56, 0x81, 0xc7, 0x27, 0x60, 0x05, 0x60, 0x59, 0x76, 0x9f, 0x50, 0x54, + 0xfb, 0x3a, 0x38, 0xaf, 0xf6, 0x0b, 0x55, 0xc5, 0xa9, 0x19, 0x5d, 0x13, + ] + ), + test_case!( + [ + 0xf4, 0xc9, 0x85, 0x8d, 0x46, 0x0f, 0x3d, 0x63, 0x9a, 0x9c, 0x31, 0x86, 0x64, + 0x05, 0x2c, 0xce, 0xb4, 0xb3, 0xb2, 0x5c, 0x95, 0xa3, 0xcf, 0xaf, 0x88, 0xa6, + 0xb0, 0x4c, 0x2e, 0xed, 0xca, 0xb1, 0xa2, 0xb6, 0x03, 0x85, 0xc2, 0x68, 0xa8, + 0xc8, 0xb2, 0x02, 0x92, 0x07, 0xf4, 0xa1, 0x6b, 0x77, 0x92, 0xdd, 0x54, 0x30, + 0x9f, 0x53, 0xcb, 0x55, 0x15, 0xb5, 0x1f, 0x7f, 0x45, 0xe1, 0x6c, 0xb5, 0xf9, + 0xed, 0xc1, 0x64, 0x52, 0xe4, + ], + [ + 0xb4, 0x3a, 0xe2, 0xe2, 0x1f, 0x71, 0x99, 0x96, 0xe1, 0x04, 0xaf, 0x74, 0x59, + 0x36, 0xdb, 0xe7, 0x65, 0x02, 0x5a, 0xc7, + ], + [ + 0x4a, 0x8f, 0xfb, 0x41, 0x16, 0xc9, 0x2c, 0x87, 0x5c, 0x95, 0x5e, 0x03, 0x25, + 0x67, 0x94, 0xe3, 0x78, 0x8f, 0x57, 0x8e, 0x48, 0x0b, 0xfc, 0xe7, 0x4f, 0x07, + 0x57, 0x9b, 0xcc, 0x6d, 0x08, 0x45, + ], + [ + 0x08, 0xbb, 0x72, 0xd5, 0xa6, 0xdb, 0xe6, 0x6a, 0x1b, 0x20, 0x12, 0x43, 0x2c, + 0x5f, 0xee, 0xa3, 0xcc, 0xff, 0xbb, 0xe2, 0xa9, 0x90, 0x52, 0x5a, 0x16, 0x82, + 0x68, 0x29, 0xab, 0x64, 0xfb, 0x3c, 0x85, 0x08, 0x91, 0x9e, 0x15, 0x52, 0xf4, + 0xd5, 0xe8, 0x09, 0x77, 0x30, 0x1d, 0xc9, 0x6a, 0xd7, + ], + [ + 0x94, 0x27, 0x6e, 0x87, 0x16, 0x21, 0x09, 0xf2, 0x31, 0xc9, 0xc9, 0x5f, 0xff, + 0x2d, 0x34, 0x9c, 0xce, 0x7f, 0x62, 0x98, 0xff, 0xe0, 0x00, 0x61, 0x9f, 0x09, + 0x21, 0x4c, 0xe5, 0xd9, 0xad, 0xb5, 0x61, 0x8a, 0xf1, 0x9f, 0xd2, 0x70, 0x0f, + 0x51, 0xa4, 0x1c, 0x72, 0x94, 0x03, 0x6b, 0x39, 0x58, 0xb1, 0x50, 0x0c, 0x29, + 0x37, 0x06, 0x1c, 0x2c, 0xc6, 0xb9, 0x67, 0x46, 0xcc, 0xec, 0xc5, 0x0e, + ] + ), + test_case!( + [ + 0x86, 0x53, 0x1b, 0x41, 0x37, 0xeb, 0x3a, 0x82, 0xd7, 0xb2, 0xca, 0x24, 0xd9, + 0xfa, 0x81, 0x48, 0xf3, 0x97, 0x20, 0xc4, 0x11, 0x08, 0x47, 0x02, 0x2c, 0x91, + 0x20, 0x20, 0xd6, 0x38, 0xa9, 0x69, 0x2d, 0x0f, 0x93, 0x4b, 0x1d, 0x66, 0xd6, + 0x59, 0xd1, 0x25, 0x9a, 0x87, 0x90, 0xba, 0x56, 0x13, 0xed, 0x7a, 0xbc, 0x5a, + 0x94, 0xf8, 0x5f, 0xfd, 0xdb, 0x01, 0x32, 0xf1, 0xe0, 0x04, 0xf2, 0xc4, 0x52, + 0x73, 0x6c, 0x3e, 0xe4, 0x70, 0xb3, + ], + [ + 0x6c, 0x50, 0x2f, 0x67, 0x62, 0x17, 0x30, 0x7c, 0xed, 0x42, 0x7a, 0xb7, 0xf4, + 0x63, 0xd0, 0xd9, 0xc9, 0xe3, 0xd6, 0x9a, + ], + [ + 0xc3, 0xc4, 0x00, 0x6e, 0x51, 0xbb, 0xbc, 0x55, 0xa3, 0xa8, 0xd2, 0x17, 0xeb, + 0x19, 0xd8, 0x29, 0x39, 0x1d, 0x3c, 0x4d, 0x30, 0xdc, 0x0d, 0xe8, 0x32, 0xbb, + 0x66, 0x59, 0x29, 0xe9, 0x7c, 0xd9, + ], + [ + 0x00, 0x6c, 0xb9, 0xe6, 0x3e, 0x95, 0x77, 0x7f, 0x97, 0xb6, 0x07, 0x97, 0x4c, + 0x3c, 0x94, 0x83, 0x7d, 0x46, 0xc0, 0xff, 0xdf, 0x22, 0xa3, 0xc7, 0x9a, 0x96, + 0x5f, 0xc0, 0x09, 0x31, 0x2f, 0x57, 0xe6, 0xb1, 0x7d, 0x5b, 0xb5, 0xdd, 0x9b, + 0x16, 0xd4, 0xbe, 0xeb, 0x87, 0xa8, 0x88, 0xda, 0x5f, + ], + [ + 0x62, 0x4a, 0x92, 0x2d, 0x96, 0xdb, 0xaa, 0x58, 0x4c, 0x47, 0x48, 0xbb, 0x8b, + 0x6a, 0xa6, 0xff, 0xe0, 0xf1, 0xc9, 0xa4, 0xd0, 0xea, 0x4a, 0xcd, 0xa8, 0x94, + 0x9a, 0x35, 0x81, 0x72, 0xfd, 0xe8, 0xcb, 0xec, 0x0b, 0x42, 0x9b, 0x10, 0x4b, + 0x08, 0xb9, 0x3b, 0x24, 0x4a, 0x4d, 0xc6, 0xcb, 0xb9, 0xaa, 0xfd, 0x3c, 0x89, + 0xe4, 0x87, 0xa5, 0xff, 0x74, 0x85, 0xa9, 0x2e, 0x23, 0x3c, 0x27, 0xe1, + ] + ), + test_case!( + [ + 0xfb, 0x68, 0x87, 0x9d, 0x96, 0x8c, 0x7e, 0xa5, 0xfd, 0x03, 0x4e, 0x21, 0x0b, + 0x75, 0x01, 0xad, 0x24, 0x34, 0x05, 0xda, 0x7f, 0x7a, 0x6c, 0x21, 0x69, 0xb0, + 0x93, 0x93, 0xb8, 0x06, 0x09, 0xd1, 0x51, 0x4d, 0x4a, 0x69, 0xfc, 0x38, 0xa0, + 0x40, 0x8c, 0xe3, 0xd7, 0xd0, 0x2b, 0xb3, 0x65, 0xc3, 0x16, 0x6d, 0xe7, 0xc0, + 0xcc, 0x44, 0x8c, 0xe9, 0x0f, 0x62, 0xe9, 0x7e, 0xef, 0xe5, 0x5d, 0x57, 0x7b, + 0x92, 0xdb, 0xcd, 0xef, 0xd0, 0xde, 0xda, + ], + [ + 0x62, 0x5d, 0x51, 0x84, 0xbe, 0x35, 0x83, 0x1f, 0x78, 0xa2, 0x56, 0xf0, 0x6a, + 0xbb, 0x40, 0x1c, 0xb9, 0xcd, 0x74, 0x15, + ], + [ + 0xe6, 0x9b, 0xc5, 0xbc, 0x32, 0x0a, 0xac, 0x84, 0x68, 0xce, 0xdc, 0x59, 0x56, + 0x79, 0x13, 0x0c, 0x14, 0x3b, 0x8e, 0xa3, 0x53, 0x40, 0x16, 0x9d, 0xc0, 0x4c, + 0x86, 0xfb, 0x4d, 0x73, 0xd9, 0xfa, + ], + [ + 0x39, 0xd1, 0x81, 0xfa, 0x34, 0x4e, 0xed, 0x3b, 0x55, 0xc5, 0x3e, 0xc4, 0xd5, + 0x3a, 0x54, 0xf6, 0xa4, 0xad, 0x6c, 0xe5, 0x82, 0xf6, 0x5b, 0x53, 0xa2, 0x1d, + 0xa5, 0x2a, 0x18, 0xfb, 0x3d, 0x01, 0x85, 0x8d, 0x54, 0x0b, 0xb1, 0xd8, 0x29, + 0x98, 0x6a, 0x12, 0xb8, 0x60, 0x6b, 0x56, 0x71, 0xf2, + ], + [ + 0x55, 0xc8, 0xdb, 0x0a, 0x39, 0x10, 0x2c, 0x4f, 0x98, 0xac, 0x8a, 0x06, 0x41, + 0xaa, 0x63, 0x3b, 0xd4, 0x21, 0x74, 0x7a, 0xe8, 0xb9, 0x5a, 0x9f, 0xd4, 0x91, + 0xcd, 0x49, 0x5a, 0x29, 0x7a, 0x8c, 0x98, 0xd1, 0xda, 0x1c, 0xb2, 0x50, 0xc4, + 0x26, 0xf6, 0x40, 0x21, 0x6c, 0x15, 0x11, 0xee, 0x82, 0x1a, 0xc2, 0x6e, 0xd9, + 0x69, 0x1c, 0xd2, 0x0e, 0x18, 0xa5, 0x6a, 0xaa, 0xd5, 0x1a, 0xa3, 0x76, + ] + ), + test_case!( + [ + 0xc5, 0xba, 0x96, 0x79, 0xdd, 0x18, 0xe9, 0xb8, 0xcb, 0xd3, 0x8a, 0x60, 0x89, + 0xd6, 0xec, 0x41, 0x2f, 0x8c, 0x11, 0xc0, 0x17, 0xab, 0x9d, 0x3c, 0xa6, 0x1f, + 0x62, 0xe8, 0x0b, 0x4b, 0xdf, 0xca, 0xe5, 0x62, 0x7a, 0x61, 0x56, 0x45, 0xc1, + 0xc0, 0x47, 0x34, 0x24, 0x54, 0x0f, 0xa1, 0xe6, 0xfc, 0x2c, 0x45, 0xac, 0xb1, + 0xe6, 0xde, 0xf1, 0x25, 0x84, 0x9e, 0xec, 0xea, 0xcd, 0x1e, 0x5f, 0xce, 0x06, + 0xed, 0xe9, 0x74, 0x65, 0x40, 0x45, 0xaf, 0x5a, + ], + [ + 0x7b, 0xa7, 0x92, 0xbe, 0x42, 0xb6, 0x4a, 0x49, 0xa6, 0xfd, 0x45, 0xfd, 0xf1, + 0x39, 0x43, 0x99, 0xed, 0x51, 0x45, 0x8d, + ], + [ + 0xae, 0x5e, 0xa0, 0xbd, 0x47, 0xd7, 0xd4, 0x55, 0xd2, 0xbe, 0xd1, 0x9b, 0x07, + 0x41, 0xaa, 0x48, 0x84, 0x1c, 0x25, 0x77, 0x5a, 0x2a, 0xdf, 0x02, 0xc6, 0x78, + 0xf8, 0xe3, 0x58, 0xfe, 0x75, 0xbb, + ], + [ + 0x38, 0x42, 0xfa, 0xb6, 0x98, 0x8f, 0xa4, 0x75, 0x84, 0xd8, 0xb4, 0x31, 0x04, + 0x6b, 0x8c, 0x2f, 0xfe, 0x90, 0x32, 0xf6, 0xa2, 0x03, 0x1c, 0xce, 0x0e, 0x0d, + 0x23, 0xd1, 0x1e, 0xc4, 0xa9, 0x07, 0x68, 0x30, 0x9b, 0x06, 0x2b, 0x0f, 0xd3, + 0xb7, 0x7f, 0x84, 0xa2, 0x3b, 0x3e, 0x6e, 0xa8, 0x0b, + ], + [ + 0xf1, 0x3e, 0x07, 0xb9, 0x52, 0x68, 0xc9, 0xa5, 0x22, 0xa6, 0x75, 0xac, 0x0c, + 0x36, 0x97, 0xf3, 0x1c, 0x48, 0xab, 0x11, 0x73, 0xb6, 0x6f, 0x2e, 0x4e, 0x56, + 0xc4, 0x00, 0x24, 0x82, 0x51, 0xa7, 0xd1, 0x64, 0x57, 0x8d, 0x25, 0x2e, 0xf8, + 0x6c, 0x57, 0x49, 0xbe, 0xb9, 0x8f, 0x49, 0xb1, 0x19, 0x2c, 0xa1, 0xda, 0x96, + 0xe5, 0x42, 0x2f, 0x8e, 0x9a, 0xa6, 0xfe, 0xa3, 0xb5, 0xeb, 0x46, 0x48, + ] + ), + test_case!( + [ + 0xef, 0xd4, 0x39, 0x2e, 0x58, 0x6d, 0x6b, 0x4d, 0x00, 0xff, 0xe3, 0x18, 0xbd, + 0x17, 0xbf, 0x2d, 0x76, 0x30, 0xa0, 0xd1, 0xa1, 0xdf, 0xb6, 0x19, 0xf5, 0xc6, + 0x16, 0xfb, 0x3c, 0x73, 0xc2, 0x1f, 0xd6, 0x81, 0x4f, 0x52, 0x6a, 0xc1, 0xbc, + 0x0f, 0xe1, 0x25, 0xf0, 0x95, 0x4a, 0xc1, 0x3a, 0x55, 0xa7, 0x7c, 0xa1, 0x35, + 0xe7, 0x9a, 0xca, 0xc8, 0xa5, 0x83, 0x2a, 0x14, 0x5d, 0x5d, 0x87, 0x70, 0x6f, + 0x94, 0x15, 0x3b, 0xe9, 0x21, 0x31, 0x5e, 0x35, 0xde, + ], + [ + 0xef, 0x61, 0x8f, 0x1e, 0x5e, 0x63, 0xe4, 0x5d, 0xb8, 0x8d, 0xb3, 0xfd, 0x04, + 0x39, 0x98, 0xa6, 0xd1, 0xdb, 0x90, 0x2c, + ], + [ + 0x7a, 0xdf, 0x93, 0x5e, 0xc2, 0x6c, 0x0e, 0xf2, 0x81, 0x35, 0xa4, 0xbe, 0xc6, + 0x66, 0xb1, 0xad, 0x18, 0xc3, 0x2f, 0x7b, 0x7e, 0xd1, 0x77, 0x1b, 0x79, 0xe2, + 0x80, 0xe3, 0x6f, 0x11, 0x47, 0x9e, + ], + [ + 0xa5, 0xc4, 0x16, 0x17, 0x33, 0x73, 0x61, 0x8e, 0xcf, 0x7a, 0x81, 0x07, 0x5b, + 0xeb, 0x22, 0xce, 0xb2, 0xaa, 0xe9, 0xc6, 0x45, 0x82, 0x6d, 0x8b, 0xb7, 0x15, + 0x0f, 0x9d, 0x7b, 0x1a, 0xb4, 0xd8, 0x84, 0xc9, 0xe7, 0x99, 0xa7, 0xf5, 0xa8, + 0xb2, 0x87, 0x52, 0xd7, 0xe8, 0x17, 0xf9, 0x4f, 0xb7, + ], + [ + 0xdb, 0x79, 0x51, 0xba, 0x4c, 0x6b, 0x10, 0xac, 0xb1, 0xda, 0xd9, 0x76, 0x10, + 0xad, 0x51, 0xf3, 0x06, 0x52, 0x2e, 0x1d, 0x6f, 0x81, 0x8f, 0x23, 0xb3, 0xee, + 0x01, 0xa2, 0xab, 0x37, 0x59, 0xa4, 0x57, 0x5d, 0xb6, 0x8c, 0x7a, 0x91, 0x01, + 0xc1, 0xcf, 0xcd, 0x10, 0xbb, 0x99, 0xc0, 0xba, 0xd7, 0x8b, 0x78, 0xbd, 0x78, + 0xa5, 0xfd, 0xd2, 0xaa, 0x1e, 0xb7, 0xf5, 0xb7, 0x53, 0xe0, 0x1e, 0x64, + ] + ), + test_case!( + [ + 0x29, 0xf6, 0xd8, 0xac, 0x17, 0xc7, 0xb3, 0x48, 0xbc, 0x8d, 0x58, 0x4c, 0x4b, + 0x75, 0x68, 0x4a, 0x21, 0xf6, 0x37, 0x7f, 0x3e, 0xc7, 0x66, 0xc1, 0x6d, 0xb9, + 0x6b, 0x3a, 0x23, 0x27, 0xef, 0x37, 0x43, 0x66, 0x35, 0xe1, 0x6c, 0x34, 0x19, + 0xea, 0xfe, 0x58, 0x36, 0x80, 0x71, 0xa5, 0x5e, 0x73, 0xb6, 0x09, 0x43, 0xe8, + 0x4a, 0xf5, 0x27, 0x8c, 0x5d, 0xab, 0xb3, 0x97, 0x53, 0xae, 0xb0, 0xee, 0xbf, + 0x3b, 0x52, 0x4b, 0x73, 0x20, 0x21, 0xd5, 0x31, 0x2a, 0x7d, + ], + [ + 0x28, 0x76, 0xbc, 0xa4, 0x0f, 0x29, 0xdc, 0x6a, 0x64, 0xc3, 0xb2, 0x03, 0xbf, + 0xca, 0xfd, 0x95, 0x34, 0x27, 0x04, 0xac, + ], + [ + 0xd5, 0x3e, 0x89, 0x88, 0xac, 0x91, 0x97, 0x19, 0xd5, 0x1f, 0xe4, 0xd5, 0xaf, + 0x42, 0xe9, 0x42, 0x71, 0xde, 0x7c, 0x6b, 0x0b, 0x3d, 0x48, 0xef, 0x84, 0xad, + 0x70, 0xab, 0x6e, 0x47, 0xf0, 0x90, + ], + [ + 0x67, 0xfb, 0x2f, 0x7e, 0x1a, 0x0a, 0xe1, 0x07, 0xf6, 0x70, 0x00, 0xb1, 0x37, + 0xcb, 0x57, 0x5e, 0xaa, 0x1f, 0x6a, 0xd6, 0x66, 0xff, 0xfa, 0xbe, 0xf0, 0x63, + 0x06, 0x34, 0xa2, 0xec, 0x81, 0x1b, 0xf0, 0x92, 0xdc, 0x66, 0x02, 0x3d, 0x57, + 0x8a, 0xd8, 0x23, 0xd3, 0x1c, 0x66, 0x83, 0x3d, 0x67, + ], + [ + 0x25, 0x32, 0x25, 0xab, 0x19, 0xb5, 0x05, 0x13, 0xdb, 0x41, 0x0f, 0x5b, 0xb9, + 0x18, 0x91, 0x3d, 0xfc, 0x49, 0x29, 0x9c, 0xe2, 0x6c, 0xfd, 0xc2, 0xe7, 0x15, + 0xb7, 0x08, 0x27, 0x20, 0x8f, 0x31, 0xa9, 0x6b, 0x07, 0x61, 0xb6, 0xe3, 0x9b, + 0xcc, 0x22, 0x09, 0x04, 0xc8, 0x0f, 0xae, 0xac, 0x7f, 0xe1, 0x99, 0x3d, 0x00, + 0x2b, 0xfc, 0x64, 0x9e, 0x6a, 0x43, 0x72, 0x3f, 0x5c, 0x34, 0xa8, 0x18, + ] + ), + test_case!( + [ + 0xba, 0x34, 0xb3, 0x4e, 0xf7, 0x57, 0x8c, 0x9a, 0xe9, 0xd3, 0xc6, 0xd4, 0x19, + 0x0c, 0xd2, 0xd1, 0x87, 0x77, 0xf1, 0x2c, 0xd3, 0x40, 0x14, 0x9e, 0x6b, 0xa0, + 0x5b, 0xf0, 0x83, 0x8a, 0xc3, 0x29, 0x4d, 0x3f, 0x01, 0xba, 0x62, 0x8c, 0xc6, + 0x08, 0xae, 0x57, 0x35, 0x66, 0xac, 0xa9, 0x00, 0xda, 0x14, 0xa5, 0xdb, 0xba, + 0x2a, 0x3e, 0x85, 0x63, 0xae, 0xad, 0x1d, 0x70, 0xa5, 0x0d, 0x94, 0xe2, 0xbd, + 0x72, 0x79, 0xc0, 0x56, 0x71, 0x53, 0x49, 0x4d, 0x20, 0x69, 0x0c, + ], + [ + 0x42, 0x53, 0x8f, 0x1e, 0x36, 0xea, 0xd2, 0x86, 0xb6, 0x0f, 0x25, 0x12, 0x7a, + 0x37, 0xbb, 0x52, 0x8a, 0x33, 0x30, 0xb8, + ], + [ + 0x6f, 0xb9, 0xbe, 0x1d, 0xf1, 0x87, 0x93, 0x35, 0x31, 0xd3, 0xe3, 0x3e, 0x31, + 0x8b, 0x92, 0xfd, 0x73, 0x27, 0xe5, 0xfb, 0x08, 0xf3, 0x23, 0xb6, 0xe8, 0xa4, + 0xe9, 0x7b, 0x23, 0xfb, 0x1c, 0xf6, + ], + [ + 0x20, 0x82, 0x98, 0x77, 0xe9, 0x83, 0x62, 0xb8, 0x10, 0xe6, 0x55, 0x64, 0x54, + 0x94, 0xf4, 0x07, 0x30, 0xab, 0x57, 0x53, 0x62, 0x0f, 0x86, 0x3d, 0x49, 0x53, + 0x2b, 0x85, 0xad, 0xc1, 0xab, 0x9b, 0xb7, 0x60, 0x43, 0x55, 0xe4, 0xae, 0x01, + 0x37, 0xf6, 0xe3, 0x9d, 0x9a, 0x4d, 0xe4, 0x4b, 0x75, + ], + [ + 0x94, 0x39, 0x6c, 0xdc, 0xcc, 0xca, 0x61, 0x8a, 0x94, 0x57, 0x4c, 0x8d, 0x81, + 0x66, 0x1c, 0xf8, 0x89, 0xd3, 0x3c, 0x1d, 0x60, 0x4e, 0xae, 0x35, 0xf8, 0x26, + 0xc4, 0xc5, 0xce, 0xe9, 0xe2, 0xc0, 0xf3, 0x86, 0xba, 0x68, 0xe1, 0xc7, 0x6d, + 0xee, 0xba, 0xc0, 0x74, 0x67, 0x73, 0x65, 0x8d, 0xc2, 0x73, 0xf0, 0x9b, 0x39, + 0xb6, 0x34, 0x56, 0x00, 0xde, 0xd7, 0x39, 0xda, 0x4e, 0x8c, 0xe3, 0xee, + ] + ), + test_case!( + [ + 0xe7, 0xfa, 0x43, 0x5f, 0x27, 0xdb, 0x37, 0x40, 0x2d, 0x97, 0x0e, 0x17, 0x46, + 0x45, 0xb1, 0x46, 0x5f, 0x6c, 0xf7, 0x88, 0x6c, 0xd8, 0x18, 0xae, 0xd5, 0x6b, + 0x4f, 0x40, 0xdf, 0x28, 0x2b, 0x3e, 0x65, 0x56, 0x34, 0x0a, 0xe3, 0x81, 0x3b, + 0x83, 0xbc, 0x9a, 0x95, 0xea, 0x2e, 0xc6, 0x48, 0x39, 0x9a, 0x9a, 0xa6, 0x87, + 0x59, 0xa1, 0x29, 0xe0, 0xc0, 0xcb, 0x3e, 0x45, 0x72, 0xfc, 0x1e, 0x7d, 0x5e, + 0x72, 0x2d, 0xc2, 0x01, 0xa0, 0xf3, 0xc1, 0xc4, 0x1c, 0x68, 0x16, 0xf4, + ], + [ + 0xe6, 0xf7, 0xa6, 0x70, 0x37, 0xdd, 0x0a, 0x54, 0xc3, 0x5c, 0xd6, 0x28, 0x1f, + 0x8c, 0x11, 0x73, 0x38, 0x71, 0xbc, 0x42, + ], + [ + 0x37, 0x64, 0xbe, 0xc7, 0x1e, 0xb8, 0xfd, 0xfb, 0x5a, 0xe8, 0xb4, 0xd7, 0x28, + 0xc5, 0x11, 0x54, 0x85, 0xd5, 0xd1, 0xb2, 0x9f, 0x50, 0x13, 0x35, 0x7c, 0x12, + 0x87, 0x3f, 0xdc, 0xef, 0xad, 0x7f, + ], + [ + 0x35, 0x5e, 0xca, 0xc7, 0x52, 0xb3, 0x3b, 0xf5, 0xfb, 0x48, 0x56, 0x15, 0xb3, + 0x92, 0x1a, 0x0b, 0x85, 0x90, 0xac, 0x84, 0x56, 0xf2, 0x6a, 0x7d, 0x2f, 0x7b, + 0x03, 0x2a, 0x2a, 0xc5, 0x35, 0x76, 0x25, 0x5b, 0x4d, 0x9e, 0xcf, 0xbf, 0x5f, + 0x9a, 0xa1, 0x86, 0x5f, 0xc4, 0xd7, 0xed, 0x13, 0xe6, + ], + [ + 0x02, 0xf2, 0x7e, 0x98, 0x3e, 0x60, 0xf6, 0x2b, 0x40, 0x8d, 0x94, 0x28, 0xd8, + 0xed, 0x6e, 0x2b, 0x6c, 0x55, 0x89, 0x48, 0x54, 0x07, 0xc7, 0x8c, 0xcb, 0x3c, + 0x71, 0x08, 0xd2, 0x06, 0x0b, 0xf2, 0x4e, 0x5c, 0xe7, 0x26, 0x6d, 0xd4, 0x7a, + 0xde, 0xd0, 0xd5, 0xab, 0xdf, 0xe9, 0xf2, 0x78, 0xbb, 0x35, 0x88, 0x06, 0xdd, + 0x34, 0x5a, 0x05, 0x12, 0x33, 0x9b, 0x69, 0xda, 0xcf, 0x28, 0x46, 0x7c, + ] + ), + test_case!( + [ + 0x58, 0xab, 0xd6, 0x8c, 0x2c, 0xa5, 0x97, 0x40, 0x6c, 0xde, 0xdb, 0xef, 0xa2, + 0x3c, 0xbc, 0xd7, 0xd8, 0x66, 0xaf, 0x36, 0x06, 0x8c, 0x80, 0x3f, 0xbd, 0xa6, + 0xb2, 0xcb, 0xb2, 0x4b, 0xa0, 0x47, 0xec, 0xcf, 0xc2, 0xe7, 0x37, 0xbe, 0xa9, + 0x6c, 0x8f, 0xcd, 0x92, 0xe4, 0x3f, 0xd3, 0x92, 0x70, 0x25, 0xd9, 0x03, 0xbf, + 0xb4, 0x27, 0xf7, 0xc5, 0x34, 0x0e, 0x69, 0xae, 0x9a, 0x2e, 0x0a, 0x77, 0xf7, + 0x3e, 0xda, 0x5e, 0x28, 0x96, 0xb3, 0xa0, 0xca, 0x43, 0xd6, 0xd6, 0x22, 0x17, + ], + [ + 0xa0, 0xff, 0x83, 0x7d, 0xbb, 0xdc, 0xc5, 0x69, 0x0a, 0xf0, 0x82, 0x92, 0x8e, + 0x72, 0xec, 0x37, 0xb7, 0x46, 0x22, 0xb4, + ], + [ + 0xf9, 0x4d, 0xac, 0xdd, 0x0b, 0x44, 0x59, 0x1a, 0x34, 0x8f, 0xaa, 0x32, 0x48, + 0x95, 0x7a, 0xbf, 0x64, 0x19, 0xd2, 0xe3, 0xd3, 0x95, 0x61, 0x5d, 0x93, 0x9f, + 0x55, 0x48, 0xe2, 0x1d, 0xe2, 0xb7, + ], + [ + 0x80, 0x7b, 0x2b, 0x14, 0xd5, 0x29, 0x31, 0xf3, 0x00, 0xfa, 0x1c, 0x48, 0xe4, + 0xea, 0xcc, 0xb7, 0xed, 0x26, 0x17, 0x93, 0xe8, 0x52, 0x9f, 0xf2, 0xc5, 0x3e, + 0xc2, 0x14, 0x04, 0xd3, 0xef, 0x9a, 0x3a, 0xb1, 0xe0, 0xb4, 0x13, 0xbb, 0x8c, + 0x3c, 0x95, 0x44, 0x2b, 0xa6, 0x02, 0x04, 0x1e, 0x13, + ], + [ + 0xc8, 0x92, 0x8b, 0x40, 0xc0, 0x1a, 0xd8, 0xbb, 0x9b, 0xc7, 0x02, 0xd0, 0x43, + 0x19, 0xf3, 0xac, 0xdc, 0x88, 0x3a, 0x06, 0x81, 0x85, 0x2e, 0xfb, 0x62, 0x5b, + 0x35, 0x38, 0x7f, 0x17, 0x0e, 0xfa, 0x04, 0xe3, 0x54, 0xa9, 0x45, 0xc2, 0x4a, + 0x8e, 0x59, 0xf4, 0x23, 0x67, 0x9e, 0x7c, 0xba, 0xda, 0x32, 0xcb, 0xac, 0xe6, + 0xbf, 0x7f, 0xd2, 0x32, 0x0c, 0xb4, 0x87, 0xb2, 0xf2, 0x9d, 0x2d, 0x06, + ] + ), + test_case!( + [ + 0xf9, 0x87, 0x3b, 0x77, 0xa7, 0xfd, 0xa1, 0x42, 0xc1, 0xc7, 0x7b, 0xa5, 0x3a, + 0x8e, 0xaf, 0x80, 0xf5, 0x97, 0xd5, 0x54, 0xfd, 0xf6, 0xc5, 0xb2, 0xcc, 0xf4, + 0x32, 0x74, 0x79, 0x3d, 0xa7, 0x19, 0x91, 0xb9, 0xe3, 0x17, 0xa9, 0xe5, 0x36, + 0x7c, 0x3d, 0x5e, 0x9c, 0x75, 0x5d, 0x6f, 0x7d, 0x31, 0x7e, 0xeb, 0xb2, 0x79, + 0xe6, 0x90, 0x87, 0x82, 0x8c, 0x9c, 0xa6, 0x7e, 0x9f, 0x5d, 0x6e, 0x63, 0x50, + 0x37, 0xd5, 0xaa, 0x69, 0x03, 0x31, 0x30, 0x45, 0x42, 0x78, 0xe7, 0x02, 0xfe, + 0x7f, + ], + [ + 0x1b, 0x3d, 0x94, 0x2f, 0xf0, 0x45, 0x64, 0x71, 0xad, 0x6e, 0xd1, 0x30, 0x56, + 0xea, 0x8d, 0xe1, 0xf0, 0xb0, 0xc1, 0xd9, + ], + [ + 0x7f, 0xc2, 0x87, 0x10, 0x9f, 0x66, 0x20, 0x20, 0x1c, 0xcd, 0x68, 0x20, 0x5a, + 0x20, 0x72, 0x67, 0xc6, 0x57, 0x39, 0x49, 0xf3, 0x6e, 0xe9, 0x81, 0xd1, 0xee, + 0x08, 0xda, 0x7e, 0xa2, 0xf0, 0x87, + ], + [ + 0x33, 0x9f, 0x29, 0x4b, 0x71, 0x67, 0x3d, 0x18, 0xd8, 0x82, 0xc7, 0xcd, 0x76, + 0x08, 0x81, 0x5b, 0x66, 0x0f, 0x4e, 0x02, 0xc8, 0xb2, 0x1d, 0xef, 0xb0, 0x0e, + 0x0f, 0xdf, 0xc8, 0x2e, 0x49, 0x10, 0x1c, 0x0d, 0x75, 0x8a, 0xb5, 0x8c, 0x98, + 0x2a, 0x43, 0x2e, 0xfc, 0xc6, 0xab, 0xf9, 0xb4, 0x47, + ], + [ + 0x3a, 0x0a, 0xae, 0xe5, 0x11, 0xb8, 0x1f, 0x6a, 0x82, 0x0a, 0x23, 0x2d, 0x55, + 0x5f, 0x09, 0xa4, 0x7d, 0x71, 0x28, 0x03, 0xb4, 0xc2, 0x14, 0xee, 0x66, 0x73, + 0x9d, 0x44, 0xd9, 0x55, 0x3d, 0xd2, 0x31, 0xc0, 0x58, 0x7d, 0x0a, 0xef, 0xf4, + 0xaf, 0xd0, 0x58, 0x34, 0x81, 0x38, 0x32, 0x1c, 0x80, 0xbc, 0xc6, 0xf2, 0xee, + 0xad, 0x1a, 0x6f, 0x39, 0x5a, 0xf7, 0x50, 0x02, 0xe7, 0x4c, 0xe1, 0x77, + ] + ), + test_case!( + [ + 0x1a, 0x9a, 0x09, 0x23, 0xe6, 0xa4, 0x56, 0x40, 0xc5, 0xa7, 0x9a, 0x80, 0x4b, + 0xa6, 0x12, 0x8d, 0xbf, 0xbc, 0xb8, 0x72, 0xbb, 0x3b, 0x5b, 0x27, 0xde, 0x84, + 0xca, 0xc9, 0x7a, 0x10, 0x3e, 0xe3, 0x09, 0x5f, 0xa9, 0x2b, 0x15, 0x5d, 0x44, + 0xa8, 0x1e, 0xa7, 0x76, 0xe2, 0x71, 0x9c, 0x0b, 0xa9, 0x2c, 0x28, 0x3b, 0xfd, + 0xdb, 0x8b, 0xb5, 0x1c, 0xbf, 0x9a, 0xe0, 0xd4, 0xf2, 0x3c, 0x38, 0xe9, 0x7b, + 0x70, 0x1a, 0x0c, 0x1d, 0x90, 0xf8, 0x10, 0xe9, 0x3e, 0x3e, 0x52, 0xde, 0x30, + 0x70, 0x17, + ], + [ + 0xd0, 0x3a, 0x32, 0x13, 0x38, 0x7a, 0x7c, 0x4d, 0xfc, 0x0a, 0xf4, 0x5c, 0x53, + 0x6e, 0x8c, 0x13, 0x23, 0x5b, 0xac, 0x03, + ], + [ + 0x26, 0xfd, 0x50, 0x21, 0x71, 0xa6, 0x85, 0xc1, 0xd6, 0x0a, 0xcc, 0xe8, 0x42, + 0x9b, 0x05, 0xec, 0xac, 0xe9, 0x1e, 0x86, 0x6c, 0x31, 0x81, 0x75, 0x19, 0x26, + 0x18, 0x27, 0xb9, 0xf0, 0x50, 0x0d, + ], + [ + 0xe4, 0xbd, 0x4a, 0x00, 0xc0, 0x29, 0x3a, 0xcb, 0x47, 0xa4, 0x63, 0xde, 0xaa, + 0x24, 0x51, 0x37, 0xbe, 0x22, 0x8c, 0x23, 0xc9, 0xdd, 0x4c, 0x05, 0x00, 0xfc, + 0x41, 0x52, 0xa2, 0xfb, 0x59, 0x63, 0xfe, 0x84, 0xce, 0x4c, 0xe8, 0x20, 0xfe, + 0x0f, 0x65, 0xf6, 0x8a, 0xeb, 0x37, 0x13, 0x68, 0xf4, + ], + [ + 0x1f, 0x2e, 0x44, 0xb9, 0x04, 0xd3, 0x3f, 0x81, 0x6e, 0x05, 0xd8, 0x4f, 0x5b, + 0x6e, 0xa0, 0x82, 0x1e, 0xbc, 0xab, 0x6a, 0xfe, 0xf7, 0xd6, 0xc8, 0x52, 0xe4, + 0xac, 0xb5, 0xd3, 0xfb, 0xa5, 0x05, 0x64, 0xf0, 0x77, 0xbb, 0x48, 0xa5, 0xf7, + 0x49, 0x37, 0x58, 0xb9, 0x2c, 0x99, 0xf9, 0x95, 0x60, 0x94, 0xac, 0x88, 0xef, + 0x41, 0x63, 0x6f, 0xec, 0x0f, 0xcd, 0x79, 0x93, 0x05, 0x3c, 0xd2, 0xc3, + ] + ), + test_case!( + [ + 0x6e, 0x3b, 0xda, 0x5c, 0x2f, 0x69, 0x90, 0x1b, 0xf4, 0x49, 0x4c, 0xea, 0x23, + 0x89, 0x63, 0xd6, 0x95, 0x48, 0x6f, 0x21, 0xfe, 0x25, 0x3b, 0xc9, 0xb6, 0xbe, + 0x5b, 0x10, 0x72, 0x3c, 0x1f, 0x5d, 0xf5, 0x91, 0xd2, 0x6e, 0x14, 0xd0, 0x55, + 0xe1, 0xa7, 0xc7, 0x2e, 0x82, 0x06, 0x29, 0x40, 0x2f, 0x3b, 0x02, 0x92, 0x7e, + 0x72, 0x56, 0x44, 0x50, 0x89, 0xa5, 0xcb, 0xda, 0x66, 0xcf, 0x79, 0xbd, 0xe0, + 0x01, 0x39, 0x8e, 0x4d, 0x66, 0xc3, 0xaa, 0xc3, 0xfc, 0x93, 0x46, 0x23, 0x7b, + 0xdd, 0x92, 0xf9, + ], + [ + 0x05, 0x6f, 0x8a, 0x01, 0xe9, 0xd7, 0x6b, 0xc5, 0xbd, 0xdd, 0x2c, 0xf4, 0xf0, + 0xde, 0xdb, 0x2a, 0xed, 0x80, 0xa9, 0x81, + ], + [ + 0x87, 0x7a, 0x27, 0xbd, 0x7b, 0xd9, 0x2e, 0xd5, 0x87, 0x99, 0x08, 0x86, 0xd1, + 0x7c, 0x44, 0x6a, 0x9c, 0x47, 0x06, 0xa5, 0x2b, 0x69, 0xd7, 0x73, 0x4a, 0x44, + 0x2d, 0x11, 0x1e, 0xbe, 0xf4, 0x7f, + ], + [ + 0xab, 0x57, 0x46, 0xf9, 0xfd, 0x65, 0x54, 0x52, 0x12, 0x00, 0xbd, 0x54, 0x56, + 0x8d, 0x00, 0xbe, 0xfe, 0xe6, 0x63, 0x6c, 0x65, 0x5c, 0x21, 0x47, 0x16, 0x23, + 0x01, 0xed, 0xda, 0x15, 0xb1, 0xea, 0x06, 0xdf, 0xdd, 0xa1, 0x44, 0xa9, 0x6c, + 0x57, 0x6b, 0x7f, 0x3c, 0xcc, 0xa1, 0xae, 0xd1, 0x81, + ], + [ + 0xe0, 0xd7, 0x16, 0x17, 0x3a, 0xc5, 0xc1, 0xf1, 0x5d, 0xed, 0x5e, 0xe7, 0x37, + 0x47, 0x06, 0x01, 0x73, 0xa4, 0x29, 0xe5, 0xeb, 0xf6, 0xfa, 0x5c, 0xbe, 0x91, + 0x22, 0xf4, 0x44, 0x47, 0x4f, 0xba, 0x92, 0x18, 0x49, 0x42, 0xcd, 0x55, 0x84, + 0x24, 0x6b, 0x26, 0xfc, 0x80, 0xee, 0xc5, 0x80, 0xbb, 0x0f, 0xf8, 0x0f, 0xd4, + 0x7a, 0x4f, 0x14, 0xa6, 0xc5, 0x13, 0xff, 0xa3, 0x32, 0xed, 0x57, 0x92, + ] + ), + test_case!( + [ + 0xaf, 0xce, 0x16, 0xf3, 0x3a, 0x89, 0xbe, 0xdd, 0x44, 0x7b, 0x3e, 0x74, 0x09, + 0x1b, 0x3d, 0x20, 0x02, 0x52, 0x65, 0x60, 0xeb, 0xeb, 0x1f, 0x72, 0x70, 0x32, + 0x61, 0xcb, 0x2c, 0xaa, 0x25, 0x40, 0x36, 0x78, 0x27, 0x14, 0x4b, 0x8f, 0x67, + 0x2a, 0xd8, 0xcd, 0x13, 0x3c, 0x44, 0xf6, 0x05, 0x11, 0xa0, 0x2e, 0x16, 0x20, + 0xa1, 0x88, 0xfc, 0xbe, 0xe8, 0x1b, 0x77, 0x86, 0x6d, 0xa0, 0x39, 0x73, 0xd0, + 0x06, 0x22, 0x63, 0xa3, 0xf9, 0xc0, 0xa1, 0x5b, 0x22, 0x71, 0x96, 0xd3, 0x5f, + 0xed, 0xbb, 0xd4, 0x00, + ], + [ + 0x30, 0x22, 0xb4, 0x8c, 0x5f, 0x18, 0x3f, 0x72, 0x20, 0x1b, 0x5d, 0xf7, 0x3d, + 0xd8, 0x3a, 0x85, 0xfb, 0xf0, 0x43, 0x4f, + ], + [ + 0x01, 0xb2, 0x31, 0x49, 0x1c, 0xf9, 0x58, 0x54, 0x6b, 0x59, 0x42, 0xbd, 0x21, + 0x0c, 0x2c, 0xef, 0xfc, 0xf3, 0x23, 0xb6, 0xc0, 0x5c, 0x75, 0x50, 0x0f, 0x74, + 0x4a, 0x68, 0x8d, 0xb9, 0x21, 0x4a, + ], + [ + 0x7c, 0x63, 0x89, 0x2d, 0x2f, 0x85, 0x5e, 0xe7, 0x8a, 0x67, 0x46, 0xad, 0xf1, + 0x93, 0x54, 0x64, 0x5b, 0x3a, 0x26, 0x40, 0x23, 0x9c, 0xfe, 0x76, 0xa8, 0x04, + 0xf8, 0x11, 0x53, 0x2c, 0xd9, 0x54, 0x6c, 0xde, 0xb9, 0xc8, 0xf0, 0x2e, 0x6e, + 0xc8, 0x3d, 0xf4, 0x63, 0x34, 0xfe, 0xb7, 0x63, 0x27, + ], + [ + 0xa8, 0x05, 0xe0, 0xeb, 0x3e, 0xa2, 0x34, 0x4c, 0x39, 0x39, 0xb8, 0x28, 0x6e, + 0xa6, 0x47, 0x26, 0x8c, 0x53, 0x26, 0x3d, 0xc4, 0x3b, 0x47, 0x38, 0x52, 0xa5, + 0xbd, 0x74, 0xd0, 0x36, 0xff, 0xaa, 0x2d, 0xf7, 0xd7, 0x10, 0xe7, 0x7b, 0x58, + 0x59, 0x2e, 0xe5, 0x96, 0x49, 0x56, 0x11, 0x03, 0x61, 0xeb, 0x26, 0xbd, 0xa9, + 0x50, 0x24, 0x3e, 0xbd, 0x10, 0xef, 0x8d, 0x0e, 0x0c, 0x65, 0x2f, 0xb0, + ] + ), + test_case!( + [ + 0x24, 0x74, 0x2b, 0xce, 0xd1, 0x3b, 0x44, 0xf8, 0xc0, 0xd0, 0xd0, 0xc3, 0xe4, + 0x11, 0x39, 0x61, 0x80, 0x69, 0xba, 0x5f, 0x04, 0xcc, 0x95, 0xf5, 0xb5, 0x68, + 0xae, 0xf8, 0xe9, 0xe9, 0x35, 0x2d, 0x66, 0x06, 0x72, 0x42, 0x1f, 0x34, 0x8c, + 0x50, 0xa7, 0x6f, 0xdb, 0x8b, 0xab, 0xa7, 0xac, 0xba, 0xa0, 0x93, 0x62, 0x7d, + 0x4b, 0xfe, 0x4a, 0xa6, 0xdd, 0xf0, 0x01, 0x02, 0xd2, 0x6f, 0x94, 0x9a, 0x07, + 0x24, 0x16, 0xba, 0x4c, 0xe8, 0xab, 0x0d, 0x43, 0xa5, 0x25, 0x96, 0xbb, 0x9a, + 0x38, 0x84, 0x97, 0xc1, 0xf7, + ], + [ + 0xb8, 0x74, 0xed, 0x06, 0x84, 0x5c, 0x68, 0x73, 0x97, 0xe2, 0xea, 0x17, 0x5c, + 0x14, 0x26, 0x85, 0xa6, 0x50, 0x3a, 0x0c, + ], + [ + 0x5e, 0x39, 0x4e, 0x4e, 0x37, 0xa2, 0x05, 0x40, 0x61, 0x95, 0x8d, 0xac, 0xbf, + 0x75, 0xcc, 0xc1, 0x14, 0x4d, 0xc8, 0xd8, 0xf9, 0x3f, 0xb7, 0x24, 0x2c, 0x9a, + 0xca, 0x3a, 0xe2, 0xae, 0x99, 0x90, + ], + [ + 0xe2, 0x71, 0xe9, 0xfc, 0xb2, 0x06, 0x60, 0xc0, 0x4a, 0xeb, 0xca, 0x45, 0xdd, + 0x72, 0x83, 0x49, 0xe8, 0xf4, 0x99, 0xb2, 0xcc, 0xc0, 0x36, 0xd7, 0xda, 0xcd, + 0xb6, 0xe8, 0xb1, 0xc1, 0x03, 0xcc, 0x9b, 0x10, 0xe4, 0x4e, 0xa4, 0xe5, 0x95, + 0xc0, 0xd4, 0x7a, 0xaf, 0x43, 0xd0, 0x33, 0x5a, 0xd0, + ], + [ + 0x63, 0xbd, 0x39, 0x1d, 0xd1, 0x46, 0xba, 0x4e, 0xde, 0xad, 0xf4, 0xb0, 0xd9, + 0xda, 0x7a, 0xff, 0x90, 0xeb, 0x48, 0x60, 0x5b, 0x7f, 0xd2, 0x9e, 0xbf, 0x2c, + 0xaf, 0x54, 0xae, 0x83, 0x7a, 0x5b, 0xfb, 0xf8, 0x25, 0xd0, 0xc5, 0x17, 0x29, + 0xac, 0xbd, 0xaf, 0x4e, 0x23, 0xa2, 0x6f, 0x42, 0x73, 0xfc, 0x7b, 0x01, 0x38, + 0xa9, 0x42, 0x1d, 0xb9, 0xe8, 0x16, 0xd3, 0xf2, 0xc0, 0xa9, 0x20, 0x9c, + ] + ), + test_case!( + [ + 0xdd, 0x89, 0xd7, 0x92, 0x13, 0xa0, 0xf7, 0xe1, 0x48, 0x3a, 0x4b, 0x14, 0x8d, + 0x04, 0xc7, 0x3a, 0xee, 0xad, 0xb3, 0x22, 0x0f, 0x94, 0xa2, 0x76, 0x12, 0x00, + 0x38, 0x70, 0x48, 0xf7, 0x8a, 0x98, 0x2a, 0x0f, 0x86, 0x85, 0x10, 0x8e, 0xf8, + 0x49, 0xff, 0x8d, 0xff, 0x26, 0xda, 0x55, 0xf0, 0xa8, 0x97, 0x10, 0x3d, 0xc2, + 0x79, 0xce, 0x2f, 0x85, 0x21, 0x1a, 0x6b, 0x00, 0x5c, 0xea, 0xbb, 0x82, 0x98, + 0x63, 0x66, 0x38, 0xaf, 0x4b, 0xf6, 0xda, 0x03, 0xda, 0xf6, 0xd2, 0xc9, 0x08, + 0xa9, 0xdc, 0x26, 0x16, 0x18, 0x96, + ], + [ + 0x6f, 0x57, 0xe8, 0x81, 0x52, 0x91, 0x70, 0x0a, 0x47, 0x94, 0x9b, 0x7a, 0x0a, + 0xcc, 0x8f, 0x9e, 0x46, 0x75, 0xe5, 0xa0, + ], + [ + 0xbc, 0x4f, 0x03, 0xf0, 0x1d, 0x98, 0x9f, 0xec, 0xd0, 0xf4, 0xe6, 0xb3, 0xfa, + 0x8b, 0x98, 0x80, 0x4d, 0xba, 0x35, 0x4f, 0xa1, 0x5f, 0x1a, 0x71, 0x84, 0x42, + 0x17, 0x57, 0xcb, 0x2d, 0xb4, 0x65, + ], + [ + 0xff, 0xc5, 0x61, 0xa9, 0x33, 0x2e, 0xb8, 0x12, 0x0f, 0x67, 0x38, 0x57, 0xde, + 0x4a, 0x46, 0x94, 0xbe, 0xae, 0xc7, 0x92, 0xca, 0x06, 0xdc, 0x85, 0xcf, 0xa9, + 0xa0, 0xd1, 0xb9, 0xf0, 0x22, 0xbf, 0x02, 0x61, 0x21, 0xf6, 0x64, 0x3a, 0x08, + 0x37, 0x7b, 0xed, 0x41, 0x9f, 0x0c, 0x71, 0x93, 0x4f, + ], + [ + 0xfb, 0x74, 0x8d, 0x63, 0x78, 0xc6, 0x9a, 0x92, 0xaa, 0xfb, 0x97, 0x0b, 0xcd, + 0x29, 0xab, 0x98, 0xe6, 0xda, 0x5e, 0xf7, 0x18, 0xf1, 0x09, 0x0a, 0x04, 0x23, + 0x38, 0x2c, 0x10, 0x42, 0x90, 0x2c, 0xaf, 0x1b, 0x7e, 0x50, 0x17, 0x77, 0xac, + 0xa0, 0xe0, 0x9e, 0xb5, 0xa4, 0xf9, 0xbb, 0x70, 0x5e, 0x57, 0xf8, 0x2c, 0xb3, + 0xa0, 0x3a, 0x2d, 0x70, 0x7e, 0x32, 0x7c, 0xaa, 0x1b, 0xef, 0xd0, 0x3c, + ] + ), + test_case!( + [ + 0x3b, 0x7c, 0xcb, 0x82, 0xa8, 0x15, 0xf2, 0x9f, 0x7b, 0x93, 0x32, 0x1e, 0x76, + 0x8e, 0x59, 0x39, 0x81, 0x1a, 0xa9, 0xd3, 0x5e, 0xc5, 0xd6, 0x1a, 0xbf, 0x31, + 0x35, 0x91, 0xc3, 0xeb, 0xeb, 0xc5, 0xbb, 0x99, 0xac, 0xc9, 0x5e, 0x67, 0x9c, + 0x02, 0x1f, 0x85, 0x4c, 0x7a, 0x10, 0x2b, 0x53, 0x0c, 0x82, 0x18, 0x21, 0x5a, + 0x09, 0x80, 0x7c, 0xb7, 0xdf, 0x81, 0x52, 0xa1, 0xe4, 0x05, 0xab, 0xef, 0xd3, + 0x21, 0x25, 0x8d, 0xa1, 0x72, 0x00, 0x10, 0x8b, 0xcd, 0xbf, 0x7c, 0xb1, 0x4a, + 0x0e, 0x7f, 0x51, 0x5a, 0xe9, 0x75, 0x06, + ], + [ + 0x8d, 0x3f, 0xeb, 0x47, 0x2e, 0xfd, 0x02, 0x3f, 0x2b, 0x20, 0x22, 0x41, 0x6d, + 0x47, 0xf1, 0xf5, 0x4b, 0x8e, 0x18, 0xbf, + ], + [ + 0x20, 0x10, 0xab, 0x80, 0x10, 0x4e, 0x64, 0x12, 0xe0, 0x59, 0x02, 0x23, 0xd4, + 0xb1, 0x38, 0x10, 0xf0, 0x54, 0xf4, 0xfa, 0x52, 0xdd, 0x9c, 0x10, 0x17, 0x62, + 0x8f, 0x5a, 0x30, 0x8e, 0x8f, 0x77, + ], + [ + 0x27, 0x03, 0xbe, 0x2e, 0x01, 0xb2, 0x45, 0xf5, 0x79, 0xc9, 0xa4, 0x00, 0xdb, + 0xdc, 0x9e, 0x16, 0x59, 0xdd, 0xb2, 0x9e, 0xf5, 0xe7, 0x8a, 0xb7, 0x21, 0xb4, + 0x83, 0xf7, 0xb2, 0x33, 0x70, 0x21, 0x28, 0x40, 0x3e, 0x3c, 0xdf, 0xfe, 0x3b, + 0x47, 0x04, 0x9e, 0x89, 0xef, 0x26, 0x75, 0x36, 0xc9, + ], + [ + 0x44, 0x09, 0x79, 0x6e, 0xf4, 0x46, 0xa3, 0xad, 0x04, 0xd6, 0x21, 0xbb, 0x2a, + 0x6b, 0x22, 0xc4, 0x88, 0xca, 0xc2, 0xc5, 0xe2, 0x0f, 0x75, 0x74, 0x87, 0xaa, + 0x1b, 0xd3, 0xc4, 0x93, 0xd2, 0x7c, 0x24, 0x6d, 0x27, 0x53, 0x5f, 0xc0, 0xa2, + 0x15, 0xe3, 0x7f, 0x46, 0xba, 0x39, 0x08, 0xcf, 0x01, 0x54, 0x95, 0xb4, 0x98, + 0x4b, 0x28, 0x9e, 0x0b, 0x87, 0xa1, 0xa1, 0xc9, 0x0d, 0x4c, 0x2b, 0x19, + ] + ), + test_case!( + [ + 0xb1, 0xc5, 0x05, 0x68, 0xf3, 0x5a, 0xcd, 0x3a, 0xd6, 0x64, 0x7b, 0x9f, 0x0e, + 0xe9, 0x6d, 0x1b, 0xa4, 0xd9, 0x29, 0xc7, 0xa5, 0x63, 0xf7, 0xe6, 0x28, 0x5c, + 0x7d, 0x44, 0x85, 0xc5, 0xde, 0x59, 0xf7, 0x0c, 0x40, 0x2a, 0x36, 0x4c, 0x38, + 0x7b, 0x40, 0x9d, 0xf7, 0xff, 0xe3, 0xb1, 0x0a, 0xe9, 0x4e, 0x85, 0x06, 0xad, + 0x8d, 0x61, 0x21, 0xb2, 0x1f, 0xab, 0x82, 0xc4, 0xaa, 0xa5, 0x12, 0xf9, 0xfe, + 0x41, 0x3c, 0xab, 0x5e, 0xcd, 0x94, 0x6e, 0x27, 0x78, 0x08, 0x65, 0xe9, 0x0a, + 0x2e, 0x56, 0x66, 0xc5, 0xbb, 0xd1, 0xd2, 0x4e, + ], + [ + 0xa7, 0x6f, 0x58, 0x3e, 0xa3, 0x3c, 0x1d, 0xb9, 0x1e, 0xb6, 0xf0, 0x66, 0x40, + 0x59, 0x1d, 0xdb, 0xdf, 0xfb, 0x6c, 0x61, + ], + [ + 0x82, 0xe5, 0x96, 0x58, 0x93, 0xad, 0x82, 0x74, 0x80, 0xb9, 0xfa, 0x58, 0xfa, + 0xae, 0x18, 0x54, 0x3f, 0xa3, 0x44, 0x27, 0x93, 0xa9, 0xa1, 0xa0, 0xd9, 0x08, + 0xcb, 0x3b, 0xa8, 0x66, 0x7d, 0x2a, + ], + [ + 0xea, 0xcd, 0x4a, 0xeb, 0x89, 0xd5, 0xfb, 0xd1, 0x46, 0x2a, 0x53, 0x5a, 0x52, + 0xd9, 0xcf, 0xc8, 0x3a, 0x25, 0xfd, 0xfa, 0x35, 0xa0, 0x46, 0xb7, 0x9c, 0x13, + 0x9a, 0x90, 0x06, 0x1c, 0x2f, 0x1e, 0x23, 0x25, 0xb2, 0x50, 0x85, 0x03, 0x69, + 0x9a, 0x5e, 0x22, 0x78, 0x89, 0x82, 0x76, 0x5f, 0x4d, + ], + [ + 0xd8, 0x19, 0x7b, 0x1e, 0x45, 0x6b, 0xbb, 0x03, 0x27, 0x34, 0xf5, 0xe4, 0xd7, + 0x78, 0x31, 0x4a, 0x12, 0x2d, 0x45, 0xbc, 0x93, 0x81, 0xeb, 0xfb, 0x9b, 0x07, + 0x4d, 0xd0, 0x52, 0x49, 0x0c, 0xf3, 0x5d, 0x28, 0xd5, 0xfe, 0xfa, 0xa8, 0x32, + 0x12, 0x47, 0x7f, 0x75, 0xc5, 0x03, 0xe1, 0x5c, 0x71, 0x97, 0xaf, 0xe1, 0x0f, + 0xc4, 0x80, 0xcc, 0xbf, 0x5a, 0x70, 0xd8, 0x89, 0xe2, 0xb7, 0x9c, 0x23, + ] + ), + test_case!( + [ + 0x68, 0x52, 0x52, 0x63, 0x7a, 0xe5, 0xa6, 0xf2, 0x2a, 0x48, 0x32, 0xe6, 0xc6, + 0xb9, 0xed, 0x30, 0x94, 0x86, 0xe6, 0x9e, 0x30, 0xba, 0x38, 0xaf, 0xcf, 0x0f, + 0xe0, 0x4f, 0xfd, 0x23, 0xa3, 0x49, 0x02, 0x89, 0xfe, 0xdd, 0xac, 0x56, 0xe9, + 0xcc, 0xf9, 0xcb, 0x69, 0x27, 0xb1, 0x8c, 0x52, 0x30, 0xa9, 0xdb, 0xad, 0x64, + 0xca, 0xef, 0x36, 0x8f, 0x83, 0x10, 0xd8, 0x27, 0x5d, 0x87, 0x4a, 0x4a, 0x54, + 0x6e, 0xcc, 0x4b, 0x01, 0x10, 0x4f, 0x18, 0x8d, 0xc6, 0x71, 0x63, 0x99, 0xd9, + 0x1b, 0xab, 0xbf, 0x5e, 0xd6, 0xae, 0x1d, 0xe7, 0x8c, + ], + [ + 0x1a, 0x98, 0x3d, 0xa0, 0xe0, 0x65, 0xb3, 0x49, 0x37, 0x73, 0xd6, 0xab, 0x88, + 0xf1, 0x9e, 0xe7, 0x11, 0x92, 0xfe, 0x2f, + ], + [ + 0x2b, 0x63, 0x5e, 0x04, 0x99, 0xde, 0x2d, 0xc9, 0x0d, 0xa0, 0xca, 0x9c, 0xc9, + 0xfc, 0xd6, 0x72, 0xc6, 0x76, 0xe8, 0xba, 0x5b, 0x60, 0x24, 0x4c, 0x80, 0x52, + 0x9d, 0x12, 0x46, 0x8b, 0xe0, 0xe4, + ], + [ + 0xe9, 0xdf, 0x02, 0x76, 0x61, 0x50, 0xad, 0x9e, 0xa6, 0xd9, 0x07, 0x5c, 0xae, + 0x70, 0x00, 0x58, 0x10, 0x83, 0xdf, 0x3c, 0xf4, 0xf3, 0x30, 0x4b, 0x56, 0xa3, + 0x47, 0x00, 0xe8, 0x78, 0x2a, 0x5e, 0x6f, 0x86, 0x84, 0x38, 0x1d, 0x3a, 0xdf, + 0x11, 0x4f, 0x13, 0xa0, 0xf2, 0x3e, 0x6e, 0x58, 0xdf, + ], + [ + 0xac, 0x23, 0xc2, 0x5a, 0x3f, 0x10, 0x1f, 0x78, 0x68, 0xe0, 0x67, 0x2b, 0xdf, + 0x51, 0xfa, 0xb6, 0x2e, 0x06, 0x21, 0x26, 0x21, 0x3f, 0xd8, 0xb7, 0x7e, 0x88, + 0x00, 0xda, 0xa2, 0x71, 0xf5, 0x09, 0x18, 0xe7, 0xc5, 0xfc, 0xb1, 0x97, 0x2a, + 0x46, 0xb9, 0x4f, 0x74, 0x92, 0x8d, 0xbb, 0xa6, 0x1c, 0xcf, 0x7e, 0x39, 0x91, + 0xe8, 0x1a, 0x68, 0x8e, 0x63, 0xaa, 0x5a, 0xcd, 0xc6, 0x7b, 0x27, 0x09, + ] + ), + test_case!( + [ + 0x50, 0xc7, 0x6d, 0x59, 0x4d, 0x87, 0x71, 0x96, 0x16, 0x17, 0xeb, 0xb8, 0xf8, + 0x07, 0xb4, 0xda, 0xd7, 0xb3, 0x7b, 0xf1, 0x8c, 0x6d, 0x75, 0x85, 0xd7, 0x1d, + 0xc5, 0x29, 0x38, 0x00, 0xd5, 0x95, 0x87, 0x10, 0xd4, 0x1f, 0x0b, 0x93, 0x49, + 0xe2, 0xe7, 0xa1, 0x5c, 0xf5, 0xaa, 0x66, 0x5b, 0xb3, 0x7c, 0x2e, 0x66, 0xa6, + 0xa8, 0xcc, 0xaf, 0xc2, 0xaa, 0xfa, 0x6f, 0xf6, 0x27, 0xc7, 0x7f, 0xab, 0xee, + 0x67, 0x38, 0x2e, 0x19, 0xeb, 0xac, 0x07, 0x87, 0x22, 0x85, 0xc6, 0x5d, 0x62, + 0x9c, 0x52, 0x34, 0x21, 0x80, 0xdf, 0x5c, 0x3d, 0x69, 0x9f, + ], + [ + 0x98, 0x5b, 0xb6, 0x6e, 0x2c, 0xc0, 0x38, 0xe1, 0xb0, 0x5f, 0x78, 0xbc, 0x44, + 0xf0, 0xd9, 0xc3, 0xa9, 0xc8, 0x35, 0x30, + ], + [ + 0xab, 0x3a, 0x81, 0x65, 0xbe, 0x03, 0xe3, 0x96, 0x80, 0xbb, 0x7f, 0xc6, 0x53, + 0x38, 0x48, 0x75, 0x53, 0xfa, 0x7f, 0xa2, 0xfc, 0x3b, 0xe9, 0xa1, 0xec, 0xe8, + 0xf0, 0x5c, 0xf0, 0x70, 0x79, 0x82, + ], + [ + 0x73, 0x00, 0x9f, 0x94, 0x7a, 0xea, 0x04, 0xcf, 0x4f, 0x4d, 0x57, 0xe9, 0xad, + 0xf7, 0xe3, 0x07, 0x66, 0xc1, 0x36, 0xe0, 0x05, 0x75, 0xe9, 0x97, 0x00, 0x6e, + 0x07, 0xec, 0xe4, 0xd8, 0x29, 0x07, 0x27, 0xf1, 0x42, 0xdd, 0x45, 0xc9, 0xa3, + 0x29, 0x9c, 0x5e, 0x1c, 0x5a, 0x33, 0x05, 0xe2, 0x7d, + ], + [ + 0x16, 0x8b, 0x4b, 0x18, 0xb8, 0x6d, 0x8b, 0x17, 0x77, 0x61, 0xa8, 0xe3, 0x38, + 0x71, 0x58, 0x47, 0x40, 0x39, 0x0e, 0x63, 0xa7, 0xbd, 0xd8, 0x87, 0x36, 0xfa, + 0x16, 0xa8, 0x86, 0x88, 0xef, 0x2e, 0xb3, 0x2d, 0xcc, 0xf6, 0xd2, 0x9e, 0x09, + 0xab, 0xf0, 0x75, 0xf7, 0x3d, 0x46, 0xe0, 0x2c, 0x09, 0x18, 0x76, 0x74, 0xfd, + 0xb9, 0xa4, 0x80, 0xd8, 0x60, 0x1f, 0xc6, 0x0c, 0xb4, 0xc9, 0x45, 0xa9, + ] + ), + test_case!( + [ + 0x3d, 0x4d, 0x10, 0xb4, 0xbb, 0x6a, 0xed, 0x74, 0x4a, 0xeb, 0xf0, 0x64, 0x45, + 0x24, 0x15, 0x5f, 0xaf, 0xdf, 0x77, 0xb4, 0xf9, 0x0a, 0xfd, 0x4c, 0x4c, 0x3d, + 0x6b, 0x87, 0x7a, 0x78, 0xe6, 0x80, 0x1c, 0x65, 0x42, 0xf7, 0x8c, 0xbe, 0xb3, + 0xb3, 0x4b, 0x65, 0xc0, 0xa3, 0x5e, 0x4a, 0x12, 0xda, 0x34, 0x57, 0xed, 0x8a, + 0xdc, 0x5c, 0xb8, 0x68, 0xd3, 0x0d, 0xca, 0xf3, 0xd8, 0xe9, 0xd6, 0x51, 0x3e, + 0x4e, 0xc6, 0xc8, 0x1a, 0x93, 0x95, 0xa5, 0x82, 0x35, 0xbc, 0x73, 0xdc, 0x09, + 0x42, 0xb7, 0x7e, 0x96, 0xb8, 0xf4, 0x20, 0x95, 0x0a, 0x64, 0x5d, + ], + [ + 0x57, 0x04, 0x84, 0x3e, 0xe2, 0x4f, 0x33, 0x37, 0x6f, 0x42, 0xf9, 0xa2, 0x6f, + 0xcf, 0x63, 0xe6, 0x35, 0xf5, 0xcf, 0x88, + ], + [ + 0x5b, 0x48, 0x0c, 0xe1, 0x2e, 0x67, 0xc3, 0x1b, 0xf8, 0xb1, 0xe9, 0x9e, 0x4c, + 0x1e, 0x57, 0xad, 0x3d, 0xb3, 0xa1, 0xe4, 0xb1, 0x16, 0x2b, 0xc5, 0x54, 0x12, + 0x17, 0x70, 0xe6, 0xaa, 0xfe, 0x86, + ], + [ + 0xb2, 0xc2, 0x3c, 0x73, 0x8c, 0xc2, 0x3d, 0x76, 0x63, 0x14, 0xb0, 0xd2, 0x84, + 0x83, 0x34, 0xe3, 0xb0, 0x38, 0x3f, 0xc9, 0x64, 0xb0, 0xf6, 0x3e, 0x49, 0x53, + 0xec, 0x4d, 0xdc, 0xbc, 0xbf, 0x6d, 0x27, 0x8c, 0x1b, 0x69, 0x3a, 0xd6, 0xe6, + 0xc7, 0xc2, 0x7f, 0xc4, 0x9f, 0xee, 0xf1, 0xb2, 0xeb, + ], + [ + 0x17, 0x65, 0x12, 0x21, 0x3e, 0x00, 0xb1, 0x52, 0x26, 0x23, 0xc8, 0x7d, 0x17, + 0x3c, 0x5e, 0x43, 0xe2, 0x9c, 0xc2, 0x57, 0x48, 0xa9, 0x7d, 0x86, 0x43, 0x88, + 0x97, 0x46, 0x58, 0xb7, 0x78, 0x29, 0x93, 0x0a, 0x42, 0x47, 0xff, 0x23, 0x42, + 0x20, 0xcf, 0x4b, 0x22, 0xb7, 0x10, 0xe1, 0x8c, 0x49, 0x11, 0x48, 0x4a, 0xb0, + 0x95, 0x86, 0x1c, 0x2e, 0x1b, 0x27, 0xce, 0x4e, 0x42, 0xc6, 0xc2, 0x78, + ] + ), + test_case!( + [ + 0xf2, 0xd7, 0x9b, 0x37, 0x30, 0x67, 0x67, 0x69, 0x7e, 0x54, 0xc7, 0xc7, 0x84, + 0xc1, 0xd5, 0xc2, 0x72, 0x18, 0x66, 0x2f, 0x5a, 0x79, 0x27, 0xd1, 0x7a, 0x61, + 0x3c, 0xfc, 0xc8, 0x13, 0xa1, 0xc2, 0x01, 0x1d, 0xa1, 0xec, 0xba, 0xe5, 0xa3, + 0x23, 0x6a, 0xd5, 0xaf, 0xf1, 0x26, 0x03, 0x8d, 0x97, 0xee, 0x71, 0xac, 0xd5, + 0xbb, 0x34, 0xcd, 0x3e, 0x55, 0x18, 0xa6, 0x37, 0x11, 0xe1, 0x8b, 0x72, 0x9a, + 0x0c, 0x19, 0x13, 0xaf, 0x3d, 0x47, 0xae, 0x23, 0x71, 0x41, 0x08, 0x39, 0x28, + 0x19, 0xe8, 0x1d, 0x81, 0x1e, 0x72, 0x4d, 0x1b, 0x32, 0x9a, 0xf1, 0xad, + ], + [ + 0x95, 0x04, 0xd4, 0x1f, 0x7d, 0x85, 0xa7, 0x38, 0xb8, 0x9e, 0x2d, 0x0f, 0x76, + 0x3d, 0x1d, 0x0c, 0xa4, 0xfa, 0xa2, 0x0c, + ], + [ + 0x29, 0x67, 0x6d, 0x2d, 0x6b, 0xa3, 0x24, 0x8a, 0x5f, 0xb0, 0x82, 0xd6, 0xd4, + 0xb8, 0xb8, 0x69, 0x49, 0x16, 0xc7, 0x74, 0x03, 0x7a, 0x73, 0x3d, 0x3f, 0x0b, + 0x50, 0xd8, 0xf5, 0x4f, 0x20, 0x5a, + ], + [ + 0x31, 0xb0, 0xa6, 0x44, 0xf2, 0x87, 0x0d, 0x48, 0x1e, 0xfe, 0x0a, 0x57, 0x05, + 0xef, 0x90, 0x0a, 0xe7, 0xb8, 0xf1, 0x16, 0x0f, 0x9a, 0x3e, 0xb1, 0x06, 0xd8, + 0xba, 0xd8, 0xe2, 0x56, 0xe5, 0xd5, 0x27, 0x25, 0x61, 0x94, 0xe3, 0x98, 0x5b, + 0x01, 0xa4, 0x08, 0x0f, 0x63, 0xac, 0xaf, 0x4c, 0xc2, + ], + [ + 0x27, 0xf0, 0x97, 0xa3, 0x38, 0xb4, 0x3f, 0x35, 0x61, 0xba, 0x16, 0x4d, 0x2d, + 0x56, 0x79, 0x23, 0x34, 0x31, 0x2b, 0x50, 0xbe, 0xf9, 0x90, 0xef, 0x99, 0x47, + 0xdb, 0x05, 0xce, 0xec, 0x07, 0xcc, 0x16, 0x5e, 0x91, 0x35, 0xa5, 0x97, 0x7a, + 0xa8, 0x8e, 0x6f, 0xc9, 0x59, 0xcb, 0x8e, 0x95, 0x03, 0xc2, 0x28, 0x20, 0x24, + 0x7d, 0x0b, 0xbf, 0x12, 0xb3, 0x50, 0xbb, 0xce, 0xca, 0x6d, 0xb9, 0xdc, + ] + ), + test_case!( + [ + 0xa1, 0xd1, 0x9f, 0xf3, 0xac, 0x76, 0xfa, 0x14, 0xed, 0xe0, 0xda, 0x5c, 0x6e, + 0x21, 0xca, 0x42, 0xb5, 0xd7, 0x76, 0x0c, 0x4f, 0x95, 0x7e, 0x94, 0xed, 0x6c, + 0x3a, 0xf6, 0xdf, 0x8a, 0xe6, 0x79, 0xa1, 0xe1, 0xd7, 0x19, 0x5c, 0x79, 0x6c, + 0xdb, 0x9f, 0xb8, 0x45, 0x7d, 0xd9, 0xca, 0x4d, 0xc8, 0x46, 0x15, 0x7e, 0xb5, + 0x76, 0x9b, 0x18, 0xca, 0xba, 0xbb, 0x34, 0x23, 0x28, 0x4d, 0x9c, 0x4b, 0x5c, + 0x66, 0x8c, 0x0f, 0x1d, 0xab, 0xaa, 0x43, 0x47, 0x49, 0x26, 0x82, 0xb5, 0xb2, + 0x2b, 0x6a, 0xa5, 0xf7, 0x41, 0xce, 0x68, 0x79, 0x77, 0xe1, 0x08, 0x93, 0xbe, + ], + [ + 0xa4, 0x05, 0x71, 0x6f, 0x05, 0xbf, 0xf0, 0xfa, 0x1a, 0x21, 0x6f, 0xbf, 0xf2, + 0x82, 0xbd, 0x33, 0x89, 0xed, 0xb7, 0xc3, + ], + [ + 0x6c, 0x0b, 0x97, 0xdf, 0xb9, 0x30, 0xbc, 0x3d, 0x16, 0x69, 0x0b, 0x6f, 0xcc, + 0x50, 0xcf, 0xa3, 0x5d, 0x31, 0xea, 0x45, 0xd7, 0x2f, 0xb6, 0x93, 0xb3, 0xbe, + 0x54, 0xe6, 0x13, 0xc3, 0x0b, 0xf2, + ], + [ + 0x52, 0x62, 0xa3, 0xbe, 0xe4, 0xe7, 0x2d, 0x69, 0x20, 0x4b, 0xda, 0x36, 0x5d, + 0x09, 0xa8, 0x09, 0xc2, 0x3f, 0x84, 0x77, 0x9f, 0xdd, 0x09, 0xfb, 0x08, 0x3a, + 0xbe, 0x9d, 0x5c, 0x71, 0xa2, 0xf2, 0xf0, 0xf3, 0xe3, 0x41, 0xa9, 0xec, 0x19, + 0x28, 0xaf, 0xa8, 0x58, 0x7f, 0xb5, 0x92, 0x2f, 0xdd, + ], + [ + 0x6e, 0xdd, 0x39, 0x65, 0x40, 0x81, 0x2f, 0x01, 0x34, 0x14, 0x9b, 0xa9, 0xb0, + 0x70, 0xdf, 0xa5, 0x23, 0xbe, 0x43, 0xb4, 0xb9, 0x16, 0x10, 0x87, 0x75, 0x41, + 0x85, 0x9a, 0xfe, 0x9c, 0xc3, 0xc0, 0x5f, 0xf2, 0x8a, 0xf1, 0xc2, 0x1c, 0xba, + 0x40, 0x2c, 0x80, 0x78, 0x5b, 0x75, 0x41, 0x31, 0xfa, 0xa3, 0xc4, 0x06, 0x5b, + 0x55, 0x79, 0x2f, 0x65, 0x82, 0x29, 0x58, 0x75, 0xf5, 0x58, 0xc5, 0x86, + ] + ), + test_case!( + [ + 0x9f, 0xd7, 0xcb, 0x9d, 0x11, 0x2c, 0xe5, 0x40, 0x9a, 0xfb, 0x0b, 0xf0, 0x97, + 0x8c, 0x46, 0xb0, 0xb3, 0x4a, 0x73, 0xb3, 0xa9, 0xac, 0xb0, 0xc8, 0x0e, 0x54, + 0x15, 0xa5, 0x2b, 0x0f, 0xae, 0xfd, 0x41, 0xf1, 0xd4, 0xae, 0xdd, 0xb5, 0x95, + 0x2a, 0x26, 0xb1, 0x66, 0x1b, 0x75, 0x3b, 0x87, 0x10, 0x39, 0xbe, 0xec, 0x04, + 0x30, 0xe1, 0x83, 0xe7, 0x4a, 0x2c, 0x0c, 0xb1, 0xee, 0x8d, 0x6b, 0xe3, 0x90, + 0x5c, 0x34, 0xa8, 0xe9, 0x21, 0xd0, 0xc7, 0x68, 0x5b, 0xc6, 0x55, 0xc0, 0x33, + 0x27, 0xc6, 0x83, 0xcb, 0x06, 0xb0, 0x6d, 0x39, 0x5a, 0x1c, 0x53, 0xd1, 0xc1, + 0x7b, + ], + [ + 0xce, 0x45, 0x1f, 0xc7, 0xa4, 0xd9, 0x11, 0x41, 0x3f, 0x92, 0xd2, 0x86, 0x32, + 0x49, 0x39, 0xcc, 0xeb, 0xaa, 0x8d, 0x29, + ], + [ + 0xd4, 0x41, 0x28, 0xd6, 0xe9, 0x8a, 0xa6, 0x8a, 0xa3, 0x4b, 0x56, 0x02, 0xb5, + 0x54, 0xf3, 0xc2, 0x63, 0xfd, 0x42, 0x2f, 0x2d, 0x2b, 0x72, 0x87, 0xf7, 0x34, + 0xb1, 0xb0, 0x10, 0x6b, 0xf3, 0xa5, + ], + [ + 0x64, 0xaa, 0x62, 0x6d, 0x73, 0x02, 0x32, 0xec, 0x4d, 0x5c, 0x4f, 0x5a, 0x00, + 0x43, 0xd1, 0x36, 0x29, 0xd1, 0x2f, 0xb3, 0x86, 0x52, 0x85, 0x97, 0x23, 0x22, + 0x72, 0x51, 0xa0, 0xbd, 0x8c, 0x79, 0x04, 0xa4, 0x22, 0x61, 0x28, 0x67, 0x9a, + 0x64, 0x00, 0x89, 0x55, 0xc7, 0xc2, 0x3f, 0x25, 0xe1, + ], + [ + 0xc1, 0xda, 0x78, 0xfe, 0xef, 0xc0, 0x3b, 0xc7, 0xaa, 0xab, 0x69, 0x63, 0x94, + 0x16, 0x0d, 0x05, 0xac, 0x17, 0xf2, 0xd8, 0x27, 0x4b, 0x1c, 0xa9, 0x1f, 0x3d, + 0xbd, 0x92, 0x81, 0xe5, 0x29, 0x51, 0x61, 0x05, 0x6d, 0x13, 0x45, 0x41, 0xc7, + 0x75, 0x29, 0xbe, 0x7b, 0x84, 0xd7, 0x3d, 0x76, 0xb1, 0x09, 0xec, 0xf7, 0x25, + 0x20, 0xa2, 0x2f, 0xef, 0xa6, 0x91, 0xe4, 0xe3, 0x6c, 0x7d, 0x20, 0x88, + ] + ), + test_case!( + [ + 0x9b, 0x15, 0x79, 0xa0, 0x52, 0xd9, 0xa1, 0x06, 0x89, 0xa1, 0x63, 0x17, 0xa8, + 0x95, 0xb8, 0x48, 0x23, 0x23, 0xb1, 0x54, 0x3d, 0x83, 0x20, 0xa5, 0x2e, 0xa2, + 0xff, 0xde, 0x30, 0x7c, 0xda, 0x29, 0x12, 0x9d, 0x76, 0x35, 0x0c, 0x62, 0x08, + 0xc0, 0x5f, 0xb2, 0xb8, 0x4a, 0x32, 0x9a, 0xd2, 0x68, 0xff, 0x9b, 0xc4, 0xa4, + 0x22, 0xae, 0x06, 0xbf, 0x00, 0x78, 0x37, 0x92, 0xce, 0xde, 0x1a, 0xf2, 0xbd, + 0x52, 0xac, 0xe5, 0x06, 0xba, 0xe2, 0x8f, 0xff, 0x87, 0xe7, 0xda, 0x8c, 0x6c, + 0xcb, 0xb4, 0xad, 0xfa, 0x8d, 0x94, 0xce, 0xdb, 0x5a, 0xe0, 0xee, 0xbc, 0x5b, + 0x61, 0x4b, + ], + [ + 0x1b, 0xf2, 0x3c, 0x86, 0x4e, 0x2d, 0x47, 0x18, 0xf8, 0xbf, 0x6e, 0x47, 0x1f, + 0x40, 0x64, 0xaf, 0xb8, 0xaa, 0xc6, 0xda, + ], + [ + 0x11, 0x71, 0x41, 0x3a, 0x6b, 0x37, 0xf1, 0x21, 0x10, 0xe8, 0xa8, 0xe5, 0x9a, + 0x56, 0xce, 0xd8, 0xb2, 0xdc, 0xff, 0xd7, 0xe7, 0x3f, 0xe8, 0x42, 0x90, 0x45, + 0x26, 0x85, 0x0b, 0xd6, 0xe0, 0xb4, + ], + [ + 0x45, 0xa4, 0x20, 0x6b, 0x1d, 0x0e, 0xc7, 0x42, 0x18, 0xf5, 0x01, 0xc4, 0xdb, + 0x04, 0x7f, 0x00, 0x04, 0xfc, 0xcb, 0x62, 0x5f, 0x7b, 0x9d, 0x47, 0x56, 0xef, + 0x52, 0x18, 0xab, 0xb1, 0x1a, 0x5e, 0x7f, 0xac, 0x62, 0xb4, 0xd5, 0x1c, 0x0c, + 0x6c, 0xbd, 0xcf, 0xf7, 0x27, 0x85, 0x1a, 0xd2, 0x6d, + ], + [ + 0x6b, 0x70, 0x22, 0x94, 0x99, 0x8a, 0x37, 0x52, 0x81, 0xa3, 0x56, 0x64, 0x25, + 0x0c, 0xc8, 0xfd, 0x6f, 0x9e, 0x72, 0xa7, 0xd2, 0x3d, 0x46, 0xa0, 0xb7, 0xe8, + 0x6f, 0x5c, 0xef, 0x4f, 0xec, 0x75, 0x99, 0x1e, 0x5f, 0xc6, 0xd1, 0xd2, 0x38, + 0x45, 0x37, 0xfa, 0x3f, 0xef, 0x1f, 0xda, 0x8b, 0xce, 0x14, 0x32, 0x58, 0x63, + 0x3e, 0x3f, 0xfa, 0x22, 0x38, 0xbd, 0x52, 0xd8, 0x69, 0xa6, 0x15, 0x2e, + ] + ), + test_case!( + [ + 0xf8, 0xb6, 0x35, 0x4e, 0x4f, 0x7a, 0xd2, 0x6f, 0xe5, 0x4f, 0x0c, 0x3a, 0xb0, + 0xe9, 0xe4, 0x70, 0x8f, 0x0a, 0x06, 0x32, 0x8b, 0xdb, 0xcb, 0xd8, 0x0a, 0x64, + 0x3a, 0x87, 0xbb, 0x41, 0x5f, 0xfe, 0x53, 0xd4, 0x48, 0xb2, 0xd6, 0xf0, 0x48, + 0x98, 0xf0, 0xc7, 0xb4, 0x92, 0x58, 0xbc, 0xbe, 0x88, 0xe2, 0x2f, 0xb8, 0x39, + 0x15, 0xce, 0x5e, 0xce, 0xb1, 0x7f, 0x39, 0xc5, 0x81, 0x27, 0x10, 0xc8, 0xbb, + 0x3a, 0x79, 0x02, 0xb1, 0xd2, 0xd5, 0x5a, 0x69, 0x48, 0xbf, 0xb3, 0xe8, 0x58, + 0xd3, 0x3b, 0xf4, 0xea, 0x26, 0xc6, 0xe4, 0x62, 0x64, 0xad, 0x5d, 0x6a, 0x36, + 0x51, 0x98, 0x53, + ], + [ + 0x65, 0x08, 0xb9, 0x99, 0xe6, 0xda, 0xd1, 0xd9, 0xd6, 0xae, 0xa4, 0xe2, 0x04, + 0xfe, 0xc3, 0xa6, 0xdc, 0x1a, 0x6c, 0x66, + ], + [ + 0x95, 0x79, 0x52, 0x84, 0xe7, 0xb8, 0xf2, 0x77, 0x1c, 0x80, 0x02, 0x4f, 0xe1, + 0xaa, 0xd8, 0x5b, 0x01, 0xe9, 0x04, 0x4b, 0xf2, 0xe0, 0x2f, 0x8d, 0x6e, 0xad, + 0x82, 0x42, 0x9d, 0xef, 0x7e, 0x42, + ], + [ + 0xf5, 0x54, 0xd4, 0xe1, 0x1d, 0xca, 0xde, 0xd3, 0x31, 0xae, 0x1f, 0x88, 0x6e, + 0x57, 0xc1, 0x56, 0xfd, 0x4a, 0x47, 0x3d, 0xba, 0x2c, 0x05, 0x84, 0x65, 0x3c, + 0x7a, 0x31, 0x58, 0xf7, 0xa2, 0x07, 0x1f, 0x7b, 0xd2, 0x2b, 0x39, 0xd2, 0x30, + 0x8f, 0xf1, 0x1a, 0x1f, 0x6a, 0x99, 0xd1, 0x8e, 0x72, + ], + [ + 0x2f, 0xdd, 0x3c, 0x16, 0xf8, 0x02, 0x92, 0xca, 0x04, 0xe6, 0xe1, 0x70, 0x20, + 0xd1, 0x23, 0x9c, 0xc7, 0xe6, 0x72, 0x41, 0xef, 0x88, 0xc4, 0x4a, 0x62, 0x55, + 0x0e, 0x44, 0xcf, 0x06, 0x21, 0xea, 0xc1, 0x42, 0x07, 0x4c, 0x31, 0x0f, 0x67, + 0x10, 0x44, 0x42, 0x96, 0xbb, 0x03, 0xbf, 0x2a, 0xe8, 0xd8, 0x72, 0x29, 0x8c, + 0x62, 0xed, 0xfa, 0xad, 0x97, 0x73, 0x93, 0x06, 0xb3, 0x4f, 0x8a, 0xe5, + ] + ), + test_case!( + [ + 0x9e, 0x58, 0x76, 0x45, 0xb7, 0x0c, 0xad, 0xf0, 0x93, 0xf1, 0x11, 0x66, 0x58, + 0x49, 0xe4, 0x5c, 0x62, 0x8c, 0x79, 0x13, 0x10, 0x5b, 0xa4, 0xc2, 0x2e, 0x31, + 0x40, 0x94, 0x7e, 0x11, 0xde, 0x90, 0xa0, 0x5e, 0xe1, 0x68, 0x9b, 0x5d, 0xd9, + 0xe9, 0xb5, 0xc1, 0x15, 0x2a, 0xf2, 0xfd, 0x4c, 0xc6, 0x38, 0xaa, 0xad, 0x51, + 0x97, 0x1e, 0x85, 0x54, 0xaf, 0x13, 0xfe, 0x82, 0x2e, 0xa0, 0xf2, 0x21, 0x93, + 0x9f, 0xf2, 0xec, 0x17, 0x6e, 0xf3, 0x63, 0x5a, 0xc2, 0xef, 0xd1, 0x66, 0x50, + 0xcb, 0xfb, 0xea, 0x6e, 0x87, 0xce, 0x8d, 0x60, 0xaf, 0xf4, 0xe4, 0xc2, 0xd5, + 0x09, 0x9e, 0x0e, 0xc0, + ], + [ + 0xf0, 0x6b, 0x4a, 0xe2, 0x29, 0xc7, 0x09, 0x9a, 0x4c, 0x5a, 0x41, 0xad, 0x7c, + 0x22, 0x9a, 0xa9, 0x77, 0xfc, 0x29, 0xd6, + ], + [ + 0x63, 0x2b, 0xfd, 0x02, 0xd7, 0xb9, 0x57, 0xa5, 0x89, 0x6d, 0x78, 0xdd, 0x49, + 0x1e, 0x57, 0x7b, 0xaa, 0xb9, 0x35, 0xe1, 0x0b, 0x81, 0xcd, 0xa4, 0xbd, 0xdc, + 0x13, 0x55, 0x4a, 0x3d, 0xac, 0x1a, + ], + [ + 0x62, 0x9d, 0x15, 0xb3, 0x88, 0xbd, 0x51, 0x39, 0x85, 0x6b, 0xbb, 0xa4, 0x05, + 0x9d, 0xc7, 0xc7, 0xcc, 0xa4, 0x91, 0x5e, 0x7e, 0x04, 0x85, 0xb2, 0xce, 0x07, + 0xf9, 0x97, 0x91, 0x72, 0xf5, 0x42, 0x36, 0x73, 0x19, 0xb8, 0x88, 0x00, 0x66, + 0xf2, 0x6b, 0x46, 0x9e, 0xfb, 0xfd, 0xd7, 0xbd, 0x3a, + ], + [ + 0x78, 0x48, 0xf2, 0xe6, 0x49, 0xf6, 0x24, 0x81, 0xae, 0x54, 0xdc, 0x17, 0x67, + 0xc7, 0x7e, 0x9a, 0x73, 0x8b, 0x3e, 0x53, 0xc5, 0xb4, 0x2e, 0x3c, 0x0e, 0x54, + 0x91, 0x07, 0x72, 0xa6, 0x6b, 0x16, 0xb1, 0xfc, 0x83, 0x5a, 0x2c, 0x73, 0x38, + 0x8c, 0xed, 0x25, 0x4c, 0xc8, 0x0b, 0x37, 0x20, 0x82, 0xe8, 0x36, 0xf2, 0x90, + 0xbb, 0x52, 0x76, 0x2a, 0xa9, 0x68, 0x6d, 0xd9, 0x9d, 0xbf, 0x74, 0x72, + ] + ), + test_case!( + [ + 0xe9, 0xa2, 0x61, 0x9a, 0x31, 0x58, 0xd8, 0xac, 0x3c, 0xa3, 0x92, 0x90, 0xba, + 0xa1, 0x97, 0x7b, 0x2e, 0xef, 0xe6, 0xda, 0x10, 0x4e, 0xd7, 0x72, 0xc8, 0xca, + 0x24, 0x5d, 0xaf, 0x6d, 0xa1, 0x41, 0x86, 0x17, 0x8b, 0x13, 0x1c, 0x01, 0x2b, + 0xa0, 0xa5, 0x08, 0x53, 0xfa, 0x31, 0xef, 0x27, 0x3b, 0x7e, 0x10, 0xaa, 0x80, + 0x3f, 0xad, 0x4c, 0xb6, 0x64, 0x0b, 0x71, 0x95, 0x4c, 0xa6, 0xa9, 0x75, 0xe9, + 0xe6, 0x95, 0x83, 0x5d, 0x57, 0x8c, 0x3d, 0xd4, 0x4a, 0x6f, 0x2d, 0xac, 0xe2, + 0xc9, 0xf3, 0x2a, 0xea, 0xee, 0x0b, 0x44, 0x90, 0x8c, 0x16, 0xd6, 0x01, 0x34, + 0x3a, 0x8e, 0x5d, 0x94, 0xbc, + ], + [ + 0x48, 0x2f, 0xf5, 0x98, 0x72, 0xf5, 0xe9, 0x3f, 0x89, 0xe5, 0xea, 0x83, 0x6c, + 0xe7, 0x7e, 0x06, 0xae, 0x81, 0x52, 0xb3, + ], + [ + 0x16, 0x62, 0x2e, 0xa3, 0xa3, 0xd0, 0x5c, 0xb2, 0xb4, 0x5d, 0x7c, 0xf2, 0x81, + 0xed, 0x7f, 0x5e, 0xc3, 0x0d, 0xee, 0x92, 0x9f, 0x0a, 0x50, 0x61, 0x5d, 0x36, + 0x69, 0x79, 0xd8, 0x0f, 0xc9, 0x0a, + ], + [ + 0x0c, 0x1e, 0xa5, 0xfd, 0x87, 0xfb, 0xa0, 0x87, 0xdb, 0x75, 0x40, 0xe2, 0x80, + 0x97, 0x1b, 0x94, 0x32, 0x29, 0xc6, 0xb9, 0x68, 0x00, 0x7a, 0x87, 0xdf, 0xa1, + 0x3a, 0x00, 0xa2, 0xfc, 0x36, 0x96, 0xbd, 0x16, 0xc2, 0x4f, 0x13, 0xc7, 0xef, + 0x7b, 0x36, 0xbf, 0xdb, 0x33, 0xa9, 0xb2, 0x6b, 0xb2, + ], + [ + 0xf1, 0xb3, 0x75, 0x86, 0x68, 0xbd, 0x5a, 0x2f, 0x5b, 0x05, 0x3c, 0x80, 0x01, + 0x72, 0xf9, 0x80, 0xa8, 0xc3, 0xba, 0x64, 0x5a, 0xcd, 0x0c, 0xca, 0x49, 0x2f, + 0x4b, 0xf1, 0x5a, 0x67, 0xcf, 0xd5, 0xae, 0xbf, 0x57, 0xad, 0x66, 0x25, 0xc6, + 0x31, 0x47, 0xc2, 0x81, 0x02, 0x45, 0x9b, 0x13, 0x94, 0x87, 0x8c, 0x05, 0x87, + 0x8a, 0x41, 0x31, 0x6e, 0x67, 0x0d, 0xac, 0x68, 0x9a, 0xbe, 0xdd, 0xdc, + ] + ), + test_case!( + [ + 0x25, 0xff, 0x04, 0x82, 0x1f, 0xae, 0xd8, 0x58, 0x6e, 0x29, 0xe6, 0xf7, 0x46, + 0xa0, 0xad, 0x30, 0xda, 0x97, 0x12, 0xce, 0x64, 0x39, 0xb4, 0xe5, 0xbc, 0xa5, + 0xa8, 0xeb, 0xc5, 0xca, 0x2e, 0x11, 0xbf, 0x46, 0x03, 0x87, 0x10, 0x95, 0x3c, + 0x55, 0x1a, 0x04, 0xfc, 0xe7, 0xac, 0xfd, 0xc3, 0x30, 0x3f, 0x24, 0x3b, 0x0c, + 0xc4, 0x3f, 0x83, 0x6b, 0x08, 0x77, 0x39, 0x6e, 0x0c, 0x05, 0x10, 0xcf, 0x8f, + 0xa0, 0x32, 0xa0, 0xed, 0x88, 0x42, 0x4c, 0x65, 0xbb, 0x39, 0xcd, 0x2f, 0x13, + 0x88, 0x6b, 0xbc, 0x46, 0x77, 0xdd, 0x98, 0xb7, 0x68, 0x9c, 0xec, 0x5b, 0x68, + 0x21, 0x09, 0x9a, 0xb5, 0xd9, 0x1e, + ], + [ + 0x90, 0x34, 0xa3, 0x1a, 0xc4, 0xe8, 0xd9, 0xe3, 0x3f, 0x63, 0xe1, 0xd2, 0xe1, + 0xbb, 0xf7, 0xf1, 0x06, 0xeb, 0xcd, 0xca, + ], + [ + 0xeb, 0x61, 0x9c, 0xc9, 0xf8, 0x0a, 0xfb, 0x28, 0x41, 0x6f, 0xed, 0xbc, 0x8c, + 0xaa, 0x9c, 0x03, 0x46, 0xed, 0x7a, 0x3a, 0x83, 0xb6, 0x71, 0xc9, 0xa3, 0x99, + 0x0f, 0x69, 0xf7, 0x7f, 0x4c, 0x80, + ], + [ + 0x35, 0xd5, 0x9a, 0xcf, 0xd9, 0x6a, 0x71, 0x81, 0x7a, 0xeb, 0x61, 0xec, 0xe3, + 0x37, 0xd8, 0x03, 0xeb, 0x0c, 0xda, 0x66, 0xa6, 0x05, 0x80, 0x61, 0x4f, 0x53, + 0x20, 0xd2, 0xdd, 0xfc, 0xfa, 0x6a, 0x6e, 0x34, 0xbb, 0x98, 0x91, 0x07, 0x4e, + 0xe2, 0x88, 0xd4, 0xbd, 0x9b, 0x2d, 0xf3, 0x3d, 0x62, + ], + [ + 0xac, 0x73, 0xae, 0xec, 0x3d, 0x6e, 0x61, 0xf4, 0x71, 0x21, 0x90, 0xa5, 0x92, + 0x98, 0x92, 0x75, 0xc0, 0xb7, 0xc2, 0x72, 0xd0, 0x45, 0xcc, 0x7d, 0x1f, 0xf8, + 0x28, 0x73, 0xa4, 0xf2, 0xd2, 0x83, 0xa0, 0xa2, 0x3d, 0xd4, 0xfd, 0x1a, 0x90, + 0x8f, 0x24, 0x09, 0x45, 0x65, 0x60, 0xeb, 0x2d, 0x5b, 0x1d, 0xbc, 0x5f, 0x26, + 0x5d, 0x33, 0x5c, 0xf3, 0xce, 0xa6, 0x3d, 0x98, 0x9f, 0xc6, 0x1c, 0xae, + ] + ), + test_case!( + [ + 0x65, 0x00, 0xdc, 0x9a, 0x79, 0x8c, 0x78, 0xb5, 0x6d, 0x46, 0xd5, 0x64, 0xfc, + 0x95, 0xe4, 0x36, 0x17, 0x24, 0xfe, 0x20, 0x74, 0xaf, 0x8e, 0xe0, 0xd9, 0xfa, + 0x38, 0x37, 0x8d, 0xc3, 0x62, 0x3e, 0x61, 0xc1, 0x05, 0x52, 0x12, 0x21, 0x38, + 0x03, 0x96, 0x9e, 0x38, 0x6f, 0xbb, 0xad, 0x33, 0xe2, 0xea, 0x73, 0x42, 0x0b, + 0x33, 0x8a, 0x73, 0x12, 0x0f, 0x43, 0x0a, 0xbf, 0x6d, 0x62, 0xf2, 0xf2, 0xaa, + 0x67, 0x04, 0xaf, 0xa7, 0xa8, 0x23, 0x79, 0xce, 0x60, 0xad, 0x49, 0x59, 0xbe, + 0x81, 0x26, 0xe7, 0x49, 0x0c, 0xd3, 0x7a, 0xbe, 0xa9, 0x92, 0x35, 0xb6, 0xe5, + 0x74, 0x2f, 0x83, 0x2a, 0x45, 0x88, 0xcc, + ], + [ + 0x42, 0xde, 0x59, 0x89, 0xb6, 0xe9, 0x5d, 0xb2, 0x3d, 0x99, 0xa9, 0xfd, 0xcf, + 0x54, 0x94, 0x6c, 0x37, 0x8d, 0xdf, 0x42, + ], + [ + 0x8c, 0x05, 0x33, 0xe5, 0xa2, 0x08, 0x36, 0xf2, 0xdc, 0x71, 0x48, 0x6a, 0x6d, + 0x4c, 0x46, 0xa4, 0xe3, 0xc6, 0xda, 0xb7, 0xb2, 0x0c, 0x08, 0x92, 0x27, 0xcf, + 0xb1, 0x56, 0xba, 0xfe, 0x3f, 0x4f, + ], + [ + 0x92, 0x82, 0x45, 0x5f, 0x18, 0x5d, 0xc0, 0x90, 0x9a, 0xdd, 0x19, 0x46, 0x51, + 0xe6, 0x74, 0xbb, 0x00, 0x1e, 0xfb, 0x1e, 0x89, 0x98, 0xf6, 0x33, 0x62, 0xf6, + 0xed, 0xee, 0xa4, 0xf5, 0x37, 0xe0, 0x77, 0x5f, 0x46, 0xfd, 0x79, 0x80, 0x97, + 0xfc, 0xf3, 0xd2, 0xdb, 0x49, 0x7e, 0xd5, 0x49, 0x09, + ], + [ + 0x48, 0x5b, 0xeb, 0xfc, 0x0b, 0xe8, 0x12, 0xc2, 0x8c, 0x1d, 0xbe, 0xf9, 0xa8, + 0xa0, 0x89, 0x57, 0xc6, 0x9d, 0xa3, 0x3d, 0x3b, 0x0c, 0x77, 0x2b, 0x93, 0xde, + 0xf9, 0xbc, 0x5e, 0xe1, 0x5e, 0xa9, 0xba, 0x7b, 0x3c, 0x19, 0xd0, 0xcf, 0x87, + 0x49, 0xff, 0xd7, 0xfa, 0x24, 0x5b, 0x98, 0xca, 0xca, 0x91, 0xff, 0xbd, 0x5c, + 0x3d, 0x4f, 0xb9, 0x36, 0x56, 0xda, 0x93, 0xfc, 0x68, 0xd7, 0x6f, 0x21, + ] + ), + test_case!( + [ + 0x4e, 0x91, 0x0e, 0x74, 0x00, 0xe8, 0xe7, 0xa0, 0x94, 0xb1, 0x85, 0x15, 0xef, + 0x7f, 0xf4, 0xf4, 0x64, 0xc9, 0xac, 0x6b, 0xca, 0xfe, 0x61, 0xa4, 0xc5, 0x54, + 0x41, 0x70, 0xe1, 0x98, 0x85, 0xe5, 0x00, 0x19, 0xd0, 0x60, 0xfe, 0x3e, 0x6b, + 0x78, 0x0e, 0xeb, 0x50, 0x15, 0x44, 0x8b, 0x05, 0xa2, 0x85, 0x3c, 0x44, 0x81, + 0x04, 0x86, 0x40, 0xd6, 0x1b, 0xf2, 0xc8, 0x2e, 0xbf, 0x5a, 0x1f, 0x7f, 0x40, + 0xe8, 0x67, 0x2d, 0x00, 0x75, 0x24, 0x3c, 0x06, 0x8b, 0x79, 0x01, 0xe3, 0x78, + 0x9c, 0x9c, 0x20, 0x98, 0x2b, 0x8f, 0x38, 0x14, 0x44, 0x3f, 0xd4, 0xbb, 0x23, + 0x15, 0x25, 0x6d, 0x17, 0xcd, 0x22, 0xe5, 0xd2, + ], + [ + 0xf4, 0x0e, 0x28, 0x97, 0x5e, 0xda, 0xcd, 0xa1, 0x9c, 0x42, 0xa6, 0xcb, 0x5b, + 0x25, 0x41, 0xa5, 0xf8, 0xd1, 0xb4, 0xd7, + ], + [ + 0x13, 0xa6, 0xf2, 0x8e, 0x6c, 0x2e, 0x7c, 0xfd, 0x30, 0xf1, 0xb6, 0x90, 0xff, + 0x1f, 0x78, 0x9a, 0xe3, 0x8a, 0xd1, 0x8e, 0xd5, 0xae, 0x0a, 0x59, 0xc3, 0xa6, + 0x1b, 0xd2, 0x4b, 0xbb, 0x3d, 0xc8, + ], + [ + 0x92, 0x8b, 0x01, 0xd8, 0xaa, 0x92, 0x19, 0x84, 0xa8, 0x85, 0xf8, 0x1a, 0x58, + 0xc5, 0xcd, 0x56, 0xda, 0xf0, 0x43, 0x04, 0xa1, 0xb1, 0xd3, 0x56, 0xa6, 0x16, + 0x12, 0x5c, 0x1a, 0x9a, 0xf4, 0x7f, 0xde, 0x3d, 0x9f, 0xc2, 0xc6, 0x53, 0x66, + 0x7e, 0xcd, 0x22, 0x8b, 0xc5, 0x01, 0xfb, 0xef, 0xae, + ], + [ + 0xcd, 0x4f, 0xf9, 0x55, 0xd8, 0x4f, 0xfa, 0xe0, 0x76, 0x64, 0x21, 0xcb, 0x06, + 0x08, 0xce, 0x62, 0xf2, 0x77, 0xbe, 0xc2, 0x8b, 0xb9, 0x13, 0x22, 0xde, 0x93, + 0x1d, 0xf2, 0x22, 0x5a, 0x73, 0x3f, 0xf6, 0xf4, 0x7e, 0x95, 0xf2, 0xae, 0xd4, + 0x65, 0x6c, 0x28, 0x3e, 0xb3, 0x89, 0x0a, 0x4e, 0xcd, 0xe0, 0x8e, 0x85, 0xe3, + 0x38, 0xdf, 0x67, 0x07, 0xa8, 0x99, 0x70, 0x2f, 0xba, 0x0b, 0x26, 0x80, + ] + ), + test_case!( + [ + 0x4c, 0x31, 0x0f, 0x63, 0x3d, 0xe8, 0xea, 0x29, 0x18, 0x82, 0xb7, 0x25, 0x8c, + 0xfa, 0x20, 0xa9, 0x9a, 0xda, 0x85, 0x4c, 0x09, 0x34, 0x0f, 0x64, 0xe7, 0x14, + 0x46, 0x37, 0x24, 0x6a, 0xa7, 0xb4, 0xa8, 0x45, 0x98, 0xb4, 0xf4, 0x16, 0x5c, + 0x2f, 0xd4, 0x1e, 0x44, 0xc3, 0xbd, 0x7d, 0xb1, 0xea, 0x23, 0x45, 0x1a, 0xaa, + 0x44, 0xfb, 0x51, 0xc0, 0x43, 0x94, 0xbe, 0x41, 0x10, 0x4b, 0x9e, 0x05, 0x8c, + 0x36, 0xe0, 0xa1, 0x3e, 0xef, 0x3d, 0x12, 0x65, 0x57, 0x80, 0x44, 0x32, 0x4b, + 0xbb, 0x55, 0xef, 0x09, 0x93, 0x11, 0xc9, 0x89, 0x9b, 0xcf, 0x2b, 0xad, 0x50, + 0xc9, 0x01, 0xb3, 0x72, 0x94, 0xc1, 0x63, 0x77, 0x6a, + ], + [ + 0x47, 0x94, 0xaf, 0x2e, 0x2d, 0xe3, 0xbd, 0x70, 0x5d, 0x83, 0x2a, 0x41, 0xeb, + 0x89, 0xe8, 0x70, 0xe7, 0x04, 0x9f, 0xa0, + ], + [ + 0x2f, 0xc0, 0xab, 0xea, 0x3c, 0xd2, 0xd6, 0x98, 0xa1, 0xb3, 0x90, 0xce, 0xab, + 0xcb, 0x0e, 0xa3, 0xd5, 0xd8, 0x6f, 0x9c, 0x1d, 0x50, 0x6c, 0xdb, 0xfd, 0x1c, + 0x0c, 0xc7, 0xab, 0x32, 0xab, 0x2a, + ], + [ + 0x40, 0x27, 0x64, 0xe5, 0x34, 0xd5, 0x7e, 0xd4, 0xe3, 0xba, 0x87, 0x26, 0x48, + 0xef, 0x87, 0xde, 0xd9, 0xe4, 0xa7, 0x16, 0xcb, 0x1e, 0x2d, 0x76, 0x46, 0xcb, + 0xc6, 0xb1, 0xab, 0x7d, 0xd6, 0xd2, 0x48, 0x62, 0x3d, 0x4b, 0xf4, 0x8d, 0xee, + 0xbd, 0xdb, 0xe3, 0xa3, 0x0f, 0xc5, 0x48, 0x01, 0xea, + ], + [ + 0xf7, 0xb7, 0x76, 0xdd, 0x38, 0xb8, 0x62, 0x76, 0x7b, 0xca, 0x79, 0x71, 0x68, + 0x73, 0x0f, 0xf6, 0x47, 0x36, 0xce, 0x1c, 0x74, 0x95, 0xb5, 0x02, 0x10, 0x3b, + 0x85, 0x44, 0x75, 0x5e, 0x85, 0xb1, 0x19, 0xa6, 0x57, 0x47, 0x41, 0xb0, 0x27, + 0x24, 0x25, 0xd9, 0xc7, 0x3d, 0xa9, 0x22, 0xe4, 0x9d, 0xe2, 0x41, 0xfc, 0xe4, + 0x56, 0x2f, 0x69, 0x9d, 0x15, 0x5b, 0xa8, 0x93, 0xc0, 0x37, 0x36, 0x05, + ] + ), + test_case!( + [ + 0x7a, 0x57, 0xb6, 0x71, 0xf8, 0x69, 0x57, 0xf7, 0xd3, 0x80, 0xf5, 0x54, 0xd0, + 0xdd, 0x97, 0xad, 0xd6, 0x58, 0x5d, 0xa2, 0x0e, 0x9c, 0xc5, 0xee, 0x07, 0xc4, + 0x79, 0x1d, 0x92, 0xcc, 0xb2, 0xa5, 0x10, 0x37, 0x4c, 0xce, 0x44, 0xd7, 0xbf, + 0xbf, 0x1d, 0x26, 0x66, 0xca, 0x6c, 0x44, 0x95, 0x98, 0x09, 0x4c, 0xd6, 0x41, + 0x14, 0xd6, 0xfa, 0x45, 0xb8, 0x39, 0x95, 0x9e, 0x83, 0xc5, 0xc3, 0x90, 0x4a, + 0xb3, 0x2c, 0x24, 0xfb, 0xe3, 0x40, 0xa7, 0xfa, 0xeb, 0x2d, 0xc6, 0xc0, 0xad, + 0x74, 0x8e, 0x48, 0x59, 0xa7, 0x64, 0x73, 0xf7, 0x2b, 0xd2, 0xb4, 0xa9, 0x83, + 0x9a, 0x69, 0x0a, 0xc9, 0x01, 0xab, 0x9b, 0x85, 0xf0, 0xa4, + ], + [ + 0x6f, 0x4b, 0x03, 0x8b, 0xd7, 0x18, 0x83, 0x41, 0xa5, 0x00, 0xc6, 0x6b, 0x83, + 0xcb, 0xdb, 0x32, 0x76, 0x70, 0xf3, 0xf1, + ], + [ + 0xf1, 0x4c, 0x09, 0xf7, 0xdf, 0x3e, 0x1d, 0x51, 0xdb, 0x5b, 0x25, 0xc9, 0xcc, + 0xbf, 0xff, 0xb8, 0xb5, 0x38, 0xb1, 0x1b, 0x4b, 0x1f, 0x01, 0xbf, 0x32, 0xe1, + 0x54, 0x2a, 0x6e, 0xdc, 0xb0, 0x8b, + ], + [ + 0x61, 0xda, 0xcd, 0xbd, 0x28, 0x18, 0xc5, 0x48, 0x6d, 0xbc, 0xb1, 0xc7, 0xde, + 0x54, 0x45, 0x92, 0x81, 0xea, 0x3d, 0x49, 0xaa, 0x06, 0xda, 0xa1, 0x9a, 0x49, + 0xdc, 0xd9, 0xe7, 0x58, 0x89, 0xe2, 0xf9, 0xec, 0xb9, 0xe9, 0xc0, 0x6b, 0x48, + 0xd0, 0x03, 0x33, 0x93, 0x4d, 0x1c, 0xe9, 0xf6, 0x3a, + ], + [ + 0x34, 0x81, 0xd0, 0xba, 0x19, 0xc4, 0xdf, 0xa6, 0x4d, 0x78, 0x64, 0xf3, 0x64, + 0xc6, 0xfd, 0x4a, 0x03, 0xc1, 0x01, 0xb9, 0x58, 0xf7, 0x7b, 0xb9, 0x3d, 0x05, + 0x3d, 0xf9, 0xf6, 0xba, 0xb0, 0x39, 0x48, 0x55, 0x48, 0x6b, 0x54, 0x02, 0x1a, + 0xbc, 0xe9, 0xec, 0xf5, 0xea, 0x2d, 0x99, 0x6a, 0x98, 0x79, 0x33, 0xf5, 0x31, + 0x3d, 0xef, 0x59, 0x54, 0x0a, 0x95, 0xb6, 0x71, 0x71, 0x3f, 0x29, 0x27, + ] + ), + test_case!( + [ + 0x41, 0xf5, 0x30, 0xf0, 0x2e, 0x95, 0x87, 0x70, 0x03, 0x97, 0xd1, 0xe2, 0x04, + 0xa4, 0x00, 0x08, 0x17, 0xeb, 0x68, 0x3e, 0xd0, 0x64, 0xca, 0x79, 0x9d, 0x0b, + 0x67, 0xbc, 0xb0, 0x79, 0xcd, 0xca, 0x78, 0x50, 0x30, 0x46, 0xb7, 0x02, 0xaf, + 0x3f, 0x3c, 0x9f, 0xe2, 0xde, 0xcb, 0x9b, 0xd7, 0x96, 0xc1, 0xfd, 0xf4, 0xca, + 0x9a, 0x2a, 0x85, 0x28, 0xf0, 0x8f, 0xe1, 0x59, 0xab, 0xdc, 0xa8, 0x6b, 0xb5, + 0x3d, 0x02, 0x8a, 0xd9, 0xa3, 0x91, 0x1b, 0xd0, 0xaa, 0x48, 0x5e, 0xb3, 0x04, + 0xb4, 0x2c, 0x36, 0xac, 0x0d, 0x2c, 0x5c, 0x12, 0x20, 0xf5, 0x4c, 0x3c, 0x91, + 0x87, 0x84, 0xad, 0x95, 0x65, 0x64, 0x7d, 0xb3, 0xba, 0x82, 0x88, + ], + [ + 0x34, 0xbb, 0x67, 0x6a, 0x86, 0x7d, 0xa8, 0x56, 0x11, 0x84, 0xf3, 0x04, 0x5e, + 0xf8, 0x1d, 0x33, 0x83, 0x54, 0xa4, 0xcd, + ], + [ + 0xaf, 0x69, 0xe7, 0x98, 0xd4, 0x88, 0x89, 0x44, 0x9c, 0x6a, 0xc7, 0xc9, 0xfc, + 0x1b, 0xcd, 0x47, 0x52, 0x39, 0x82, 0xd2, 0xa2, 0xe2, 0x9b, 0x98, 0x40, 0x88, + 0x7b, 0xd1, 0x26, 0x1a, 0x5a, 0xdb, + ], + [ + 0xe8, 0x02, 0xb8, 0x18, 0x37, 0x7c, 0x75, 0xbb, 0xb6, 0xb2, 0x56, 0x12, 0x28, + 0x39, 0xa5, 0x00, 0xc9, 0xdc, 0x0a, 0x62, 0x3c, 0xed, 0xac, 0x97, 0x04, 0x50, + 0x9c, 0x34, 0xfe, 0x4e, 0x40, 0x52, 0xcc, 0x7c, 0x65, 0x38, 0x3e, 0x01, 0x0b, + 0x2e, 0x48, 0xb5, 0x35, 0xc6, 0x54, 0x65, 0x43, 0xe7, + ], + [ + 0x6f, 0x52, 0xd8, 0x18, 0xd1, 0xf4, 0x88, 0x3d, 0xaf, 0x8c, 0xc4, 0xcd, 0x4e, + 0xe4, 0xb3, 0x29, 0x0d, 0x27, 0x06, 0x45, 0xdc, 0xbb, 0x2c, 0x5d, 0x3b, 0xd7, + 0xdb, 0xc9, 0xd9, 0xb4, 0x5a, 0xbe, 0x43, 0x05, 0xc6, 0x60, 0xaa, 0x69, 0x45, + 0x59, 0xf2, 0x39, 0xeb, 0x68, 0x05, 0x51, 0xba, 0x5e, 0x57, 0xd7, 0x95, 0x5e, + 0xec, 0x12, 0x75, 0x0e, 0x70, 0xe9, 0x03, 0xe9, 0x0b, 0xb7, 0x4c, 0x71, + ] + ), + test_case!( + [ + 0x63, 0xd8, 0x56, 0x2a, 0x0b, 0x46, 0x3f, 0xda, 0x47, 0x27, 0xa0, 0x91, 0xed, + 0x90, 0x02, 0x64, 0xd6, 0x8f, 0x0a, 0x37, 0x98, 0xa8, 0x7d, 0x24, 0xba, 0x53, + 0x8f, 0xdb, 0x7c, 0xb0, 0x9a, 0x37, 0x45, 0xe5, 0x87, 0xac, 0x67, 0xc9, 0x44, + 0xd7, 0x47, 0xb0, 0x0c, 0x67, 0x86, 0xe5, 0x3b, 0x61, 0x04, 0x2f, 0x24, 0x89, + 0x3b, 0xf8, 0xb6, 0x3c, 0x3b, 0xde, 0xcd, 0xec, 0x95, 0x6d, 0x6c, 0xbd, 0x24, + 0x39, 0x24, 0xbc, 0x0f, 0x28, 0xdb, 0x1c, 0x0a, 0x4b, 0x40, 0x08, 0x55, 0x1c, + 0xd0, 0x84, 0xcc, 0x4a, 0xaa, 0x1f, 0xaa, 0x73, 0x4a, 0xc9, 0x0b, 0x57, 0x2b, + 0x6a, 0xc7, 0x22, 0xd2, 0xf3, 0x87, 0x4a, 0xfe, 0xe4, 0x0b, 0x15, 0xdb, + ], + [ + 0x9d, 0x37, 0xab, 0x6a, 0x60, 0xcd, 0xa6, 0x80, 0x14, 0x29, 0x09, 0x23, 0xf9, + 0x78, 0xe5, 0xf3, 0x01, 0x22, 0xab, 0x0b, + ], + [ + 0x3b, 0xd1, 0xa9, 0xb1, 0xf3, 0x83, 0x1f, 0x5d, 0xfe, 0x45, 0x09, 0x17, 0xce, + 0x3f, 0x90, 0x9a, 0xaa, 0xa2, 0xa7, 0xc0, 0xd7, 0x7b, 0x2c, 0x29, 0x65, 0xe1, + 0xa5, 0x15, 0xfc, 0xf5, 0x2f, 0x4c, + ], + [ + 0xcc, 0x84, 0x9d, 0x11, 0xbe, 0xc3, 0x6a, 0xf1, 0xfb, 0xb8, 0x3b, 0x85, 0x7c, + 0x5b, 0xcc, 0xf1, 0xa6, 0x77, 0xf5, 0x96, 0xc0, 0xcc, 0xf8, 0x4e, 0x3e, 0xaa, + 0x17, 0x0b, 0xfb, 0x0b, 0xa2, 0xb1, 0xdc, 0xe6, 0xd5, 0xd1, 0x2b, 0x09, 0x3c, + 0x75, 0x80, 0x60, 0x31, 0x8b, 0x51, 0x70, 0x0e, 0xe1, + ], + [ + 0x25, 0x74, 0xa7, 0x93, 0x86, 0x18, 0x74, 0x86, 0xec, 0x04, 0x75, 0xfb, 0xe3, + 0xbe, 0x36, 0xb2, 0x33, 0xd5, 0x51, 0x31, 0x38, 0x3b, 0x5e, 0xef, 0xb0, 0x23, + 0x50, 0x91, 0xbe, 0xd1, 0x5b, 0x17, 0xc8, 0xf5, 0xe6, 0xcd, 0xce, 0x2c, 0x6e, + 0x7b, 0x2c, 0xb7, 0x09, 0x48, 0xd1, 0x70, 0xfd, 0xd1, 0xe0, 0x6d, 0x5e, 0xa9, + 0xba, 0x31, 0x61, 0xbe, 0xc3, 0x79, 0x08, 0x37, 0x44, 0x49, 0x0b, 0xf5, + ] + ), + test_case!( + [ + 0x0e, 0x5f, 0xac, 0x86, 0x14, 0xb6, 0xf5, 0x04, 0xde, 0x28, 0x18, 0x4f, 0x57, + 0xfc, 0x6e, 0xfa, 0x8d, 0x00, 0x2d, 0xb3, 0x30, 0x24, 0xc4, 0xdc, 0xb2, 0xc7, + 0x24, 0xa4, 0x4e, 0x08, 0x6e, 0xf5, 0xce, 0x88, 0x10, 0xef, 0xc2, 0x46, 0xbe, + 0x3b, 0x72, 0x31, 0xa2, 0x1b, 0xa8, 0x1e, 0xe3, 0x27, 0x9f, 0xe8, 0x34, 0x10, + 0xa6, 0xd8, 0x4a, 0xb8, 0x70, 0xfd, 0x65, 0x29, 0x60, 0xeb, 0x15, 0x53, 0xe2, + 0x24, 0xf5, 0x7e, 0xbc, 0xd7, 0x3d, 0x28, 0x9b, 0x81, 0x36, 0xe4, 0x83, 0x41, + 0x9f, 0x44, 0x3c, 0x7a, 0xe2, 0x62, 0x8f, 0xee, 0xf1, 0xa0, 0x5c, 0x13, 0x4d, + 0x43, 0x8b, 0x40, 0xd8, 0x9c, 0xf1, 0x1c, 0x74, 0x90, 0x25, 0x90, 0x68, 0xe3, + ], + [ + 0x17, 0x36, 0x80, 0x59, 0xfe, 0x8b, 0xbb, 0x09, 0xff, 0x8d, 0x41, 0x3e, 0xee, + 0x65, 0xb2, 0x39, 0x6e, 0x84, 0x0a, 0x41, + ], + [ + 0x2f, 0x7c, 0x45, 0x90, 0xa8, 0xbf, 0x38, 0xeb, 0xff, 0xaa, 0x49, 0xdb, 0xbd, + 0x9a, 0xdb, 0x3f, 0x7f, 0x11, 0x2a, 0xf5, 0x0f, 0xbb, 0x1e, 0x31, 0x07, 0x02, + 0xbf, 0x69, 0x98, 0xac, 0xbb, 0xc0, + ], + [ + 0xb0, 0x5c, 0xad, 0x84, 0x0a, 0x9f, 0x33, 0x5b, 0x84, 0x39, 0x2a, 0xfe, 0x9d, + 0x4e, 0x20, 0xb8, 0x89, 0x83, 0x1b, 0x7e, 0xba, 0x24, 0x2b, 0x19, 0x08, 0x95, + 0x0b, 0x6c, 0x2e, 0xd3, 0x74, 0x51, 0xa4, 0xaf, 0xe1, 0x7d, 0xbe, 0x23, 0xcc, + 0x56, 0xdf, 0xe3, 0xfc, 0xf4, 0xcc, 0xc6, 0x59, 0x09, + ], + [ + 0x14, 0xbd, 0xb7, 0x70, 0xc8, 0x3a, 0x3b, 0xb9, 0x7f, 0xaf, 0xe0, 0x17, 0x0a, + 0x6c, 0xdb, 0xdc, 0xf0, 0xb6, 0x68, 0x9f, 0xe9, 0xa4, 0xf7, 0x9e, 0x14, 0xef, + 0x9d, 0xda, 0xb7, 0xa0, 0x9a, 0xd8, 0x79, 0x4d, 0xd8, 0xbf, 0xed, 0x2d, 0x52, + 0xa2, 0xb4, 0x38, 0x68, 0x06, 0x9e, 0x41, 0x38, 0x3a, 0x4b, 0x2c, 0x30, 0x2d, + 0xee, 0xee, 0x03, 0x9e, 0xa9, 0x75, 0xec, 0xa3, 0x96, 0x1f, 0x07, 0x13, + ] + ), + test_case!( + [ + 0x98, 0x9d, 0x34, 0x47, 0x65, 0xd1, 0xe7, 0xf4, 0xb5, 0x19, 0x7b, 0xb6, 0x44, + 0x55, 0x30, 0x8e, 0x83, 0xe0, 0x29, 0xba, 0x33, 0xc0, 0x50, 0xdf, 0xfd, 0x22, + 0xb2, 0xec, 0x5b, 0x46, 0x0f, 0x38, 0xf9, 0x23, 0x85, 0x66, 0xd9, 0xbd, 0x9f, + 0x83, 0xe3, 0x5a, 0x24, 0x1e, 0x7a, 0x72, 0xa8, 0x6c, 0x2b, 0xe9, 0xe1, 0xf6, + 0xec, 0xd1, 0xcf, 0x08, 0xce, 0xa1, 0xf7, 0x07, 0xd7, 0x38, 0xa5, 0x05, 0x86, + 0xc0, 0x09, 0xbe, 0x10, 0x0e, 0x6f, 0xca, 0xf0, 0x39, 0xaf, 0xaf, 0x95, 0x52, + 0xc8, 0x8b, 0xd9, 0x10, 0x7e, 0xdb, 0x32, 0xa4, 0xda, 0x8a, 0xef, 0xa3, 0xe0, + 0xc7, 0xe2, 0x07, 0x9f, 0x12, 0x09, 0xcc, 0x2d, 0x7a, 0xe2, 0xa9, 0x96, 0xf1, + 0xcd, + ], + [ + 0xc2, 0x27, 0x51, 0xbc, 0x2c, 0x1a, 0x4c, 0x91, 0xe4, 0xcc, 0xf3, 0xaf, 0x37, + 0xd0, 0xbd, 0x4b, 0xee, 0xc5, 0xc0, 0x40, + ], + [ + 0xd5, 0xfe, 0x72, 0x21, 0x4f, 0x27, 0x10, 0x17, 0x5b, 0x7a, 0xda, 0x27, 0x22, + 0xb7, 0x05, 0xd2, 0xdb, 0xab, 0xf2, 0xdd, 0x69, 0x26, 0x4d, 0xbb, 0x5f, 0xe6, + 0xa5, 0x50, 0xcc, 0x5a, 0x56, 0x43, + ], + [ + 0x0f, 0x00, 0x36, 0xf2, 0x53, 0x6b, 0x7b, 0xff, 0xbc, 0xe4, 0x1a, 0x48, 0xd9, + 0x92, 0x89, 0xf0, 0x11, 0xb0, 0x43, 0x4b, 0x4a, 0xd5, 0x55, 0x8a, 0xd2, 0xd0, + 0x80, 0x4b, 0x41, 0x81, 0xc3, 0x35, 0xf0, 0x3c, 0xc1, 0xab, 0xc3, 0x87, 0xda, + 0xe2, 0x28, 0x22, 0xfb, 0x5d, 0x33, 0x32, 0x3b, 0x0c, + ], + [ + 0x40, 0xcf, 0xe8, 0xc5, 0x02, 0xc4, 0x89, 0x08, 0xaf, 0x10, 0xec, 0x65, 0x88, + 0x12, 0xde, 0xee, 0x94, 0x3a, 0x45, 0x18, 0x7c, 0x83, 0xdd, 0x03, 0xe0, 0x99, + 0x44, 0x3f, 0x8c, 0xf5, 0xe6, 0x0c, 0x2f, 0x00, 0xc0, 0xbf, 0xb0, 0x9c, 0x36, + 0x96, 0x9e, 0x33, 0x2f, 0xae, 0x5f, 0x9d, 0x76, 0x0e, 0x03, 0x90, 0x31, 0x1c, + 0xca, 0x3b, 0x82, 0x8b, 0x6b, 0x4b, 0x58, 0x19, 0xc3, 0x6f, 0xd0, 0x3a, + ] + ), + test_case!( + [ + 0xc6, 0x7e, 0x6d, 0xa1, 0x5a, 0x82, 0x7b, 0xbe, 0x2c, 0x40, 0x56, 0xfe, 0xf8, + 0x59, 0xcc, 0x95, 0x7a, 0xcc, 0x51, 0x6d, 0x93, 0xe9, 0xc3, 0x34, 0x60, 0x1d, + 0x2e, 0x60, 0x74, 0x97, 0x60, 0x36, 0x41, 0xd5, 0x62, 0x70, 0x61, 0xc4, 0x4d, + 0x3c, 0xea, 0xd5, 0x8a, 0x12, 0x2b, 0x3a, 0x8e, 0xab, 0xbd, 0xd1, 0x7c, 0x43, + 0xc4, 0x9b, 0x34, 0xb4, 0x9b, 0x0c, 0x4a, 0x8f, 0xd3, 0xa0, 0xcf, 0x8c, 0x60, + 0xf4, 0xde, 0xee, 0x15, 0xfd, 0xe9, 0x0c, 0xdd, 0x32, 0x4e, 0x6e, 0xb2, 0x77, + 0x83, 0xd8, 0x6a, 0x0b, 0x83, 0xa7, 0x68, 0x8f, 0x07, 0x35, 0xa8, 0x83, 0x65, + 0x92, 0x1f, 0x16, 0xc4, 0x63, 0xe0, 0xeb, 0xc9, 0x20, 0xa2, 0x95, 0xbc, 0x5a, + 0x28, 0x5f, + ], + [ + 0xe0, 0xdb, 0x00, 0xfd, 0x72, 0x76, 0x2a, 0xfc, 0x34, 0x46, 0x6b, 0xd8, 0xaf, + 0x74, 0x1c, 0xa7, 0x59, 0xfc, 0x70, 0xd5, + ], + [ + 0x80, 0xf0, 0xd5, 0x5c, 0x1a, 0x8f, 0x04, 0x21, 0x7c, 0x06, 0x8e, 0x3b, 0x55, + 0xaa, 0x52, 0xdb, 0x4a, 0x96, 0xde, 0xea, 0x68, 0x4d, 0x7f, 0xd0, 0x67, 0xc3, + 0xd1, 0xf4, 0x52, 0x02, 0x68, 0x25, + ], + [ + 0x6e, 0x14, 0x19, 0xba, 0xf9, 0x81, 0x5f, 0x21, 0xf3, 0x9e, 0x57, 0x8c, 0xe1, + 0xb7, 0x39, 0x2f, 0xd6, 0xf2, 0xfe, 0xe1, 0xd5, 0x16, 0xc3, 0xc4, 0xb8, 0x69, + 0xae, 0x70, 0xf8, 0xb4, 0x63, 0x7b, 0xdb, 0x27, 0xc3, 0x4a, 0x80, 0xde, 0xa0, + 0xcb, 0x82, 0xa7, 0x1e, 0x87, 0xc0, 0xbe, 0x7f, 0xf3, + ], + [ + 0xf0, 0x83, 0x7b, 0x73, 0x65, 0x95, 0x96, 0x4c, 0x95, 0xc1, 0xf5, 0x1e, 0x82, + 0xdf, 0xae, 0x41, 0xa5, 0x71, 0x26, 0x52, 0x95, 0x01, 0xbb, 0x3d, 0x45, 0x0c, + 0xae, 0xb6, 0x8a, 0xba, 0x6d, 0xeb, 0xad, 0x57, 0xf4, 0x31, 0x92, 0x3a, 0x4d, + 0xa3, 0x32, 0x45, 0xfe, 0x72, 0x05, 0x5a, 0xae, 0xa0, 0xd9, 0x3e, 0x18, 0x21, + 0x5b, 0x54, 0xe7, 0x48, 0xab, 0x9c, 0x87, 0xcd, 0xf2, 0x0a, 0x20, 0x8c, + ] + ), + test_case!( + [ + 0xae, 0x49, 0x35, 0xad, 0xdc, 0xa1, 0x98, 0x8a, 0x06, 0x46, 0xf9, 0x75, 0xaa, + 0x8b, 0x96, 0xd3, 0xd1, 0x67, 0xea, 0x8e, 0x9a, 0xc6, 0xc4, 0xcb, 0xe0, 0xa8, + 0xa6, 0xa0, 0x1c, 0x34, 0x19, 0x29, 0xd5, 0x46, 0x0b, 0xd6, 0x36, 0x09, 0x3b, + 0xa7, 0xf3, 0xd1, 0x9d, 0x6f, 0x29, 0xbd, 0x63, 0xcd, 0xbc, 0xe8, 0x2a, 0x49, + 0x98, 0x1f, 0x38, 0xd6, 0xda, 0xb0, 0xdf, 0x5e, 0x33, 0x00, 0x08, 0xfd, 0x11, + 0xe1, 0x4d, 0xa0, 0x39, 0x78, 0xba, 0x83, 0x76, 0x60, 0xed, 0x7e, 0x1f, 0xa3, + 0xcf, 0x6b, 0xcb, 0x9c, 0x78, 0xf7, 0xb9, 0x9e, 0xb8, 0xd8, 0x33, 0xcb, 0x42, + 0x8d, 0x1f, 0x3a, 0x9f, 0xcc, 0x44, 0x6a, 0x7a, 0x1d, 0x73, 0x4c, 0xdc, 0xf6, + 0x05, 0x6b, 0xbc, + ], + [ + 0x13, 0x40, 0x12, 0xcc, 0x6f, 0x06, 0x07, 0xa1, 0x64, 0x38, 0x57, 0xfb, 0xfe, + 0x05, 0x55, 0xf0, 0x84, 0xe3, 0x79, 0x0c, + ], + [ + 0x5b, 0x7d, 0x4d, 0x7f, 0x3e, 0x7c, 0x02, 0xe6, 0xeb, 0x3a, 0x53, 0xc3, 0x1c, + 0x24, 0xcf, 0x5c, 0xc2, 0x69, 0x97, 0x29, 0x7e, 0x7a, 0x2e, 0x71, 0xc7, 0x4e, + 0xc0, 0x96, 0xf4, 0x9b, 0xda, 0x30, + ], + [ + 0x0a, 0x5a, 0xcb, 0xc2, 0x72, 0x47, 0x41, 0xa4, 0xf7, 0xcb, 0x3d, 0x9a, 0x13, + 0x75, 0xa9, 0x37, 0xd6, 0xe3, 0x79, 0x1c, 0x24, 0x3f, 0xea, 0xb3, 0x0e, 0x3e, + 0xc0, 0xb2, 0xea, 0x67, 0xe5, 0xce, 0xf1, 0xd0, 0xf7, 0xa1, 0x5e, 0x32, 0x44, + 0x42, 0x97, 0xbb, 0xa8, 0x82, 0xaf, 0x42, 0x42, 0xd1, + ], + [ + 0x75, 0xb5, 0x1e, 0x80, 0x80, 0x56, 0xd7, 0x67, 0x23, 0x63, 0xc8, 0x4e, 0x7a, + 0xfd, 0x13, 0x4e, 0x27, 0x90, 0xfb, 0xad, 0xcb, 0x49, 0x7d, 0x1c, 0x49, 0x0a, + 0x61, 0x2a, 0x80, 0xbc, 0x47, 0x60, 0x3b, 0x35, 0x0d, 0x76, 0xa2, 0x14, 0x50, + 0xbd, 0x22, 0x94, 0xc9, 0x63, 0xd5, 0x48, 0xa3, 0x2d, 0xb0, 0x13, 0x63, 0x49, + 0x02, 0xc8, 0x3d, 0x8d, 0x32, 0x5d, 0x8d, 0x13, 0x09, 0x01, 0x5d, 0x1c, + ] + ), + test_case!( + [ + 0x08, 0x39, 0x24, 0xb6, 0x21, 0xd2, 0x2e, 0x80, 0x5f, 0xd2, 0x73, 0x84, 0x8e, + 0x71, 0x3b, 0x9f, 0x31, 0x8d, 0x10, 0x8a, 0x75, 0x41, 0xfa, 0x87, 0xbc, 0x6b, + 0xa1, 0x4c, 0x4d, 0xd9, 0xfb, 0xbe, 0xf3, 0x6f, 0x10, 0x4a, 0x91, 0xc7, 0x58, + 0x26, 0x57, 0x31, 0x52, 0x4f, 0x59, 0x49, 0xae, 0x47, 0xc0, 0xac, 0xb3, 0x99, + 0xfd, 0x52, 0x27, 0x41, 0xd6, 0xfa, 0x59, 0x1e, 0x1e, 0x45, 0xcc, 0x17, 0x5b, + 0x4e, 0x29, 0x54, 0xad, 0xb9, 0xf7, 0xa1, 0x6f, 0x8b, 0x94, 0x40, 0xbb, 0x12, + 0xd3, 0x3b, 0x32, 0x76, 0xc9, 0xa9, 0x99, 0x70, 0xda, 0xe8, 0x79, 0x7a, 0xee, + 0xe2, 0x3e, 0xb9, 0x4d, 0x43, 0xf0, 0x49, 0x1e, 0x02, 0x63, 0xec, 0xf5, 0x25, + 0xbb, 0x0f, 0x44, 0x26, + ], + [ + 0x54, 0x8e, 0x7a, 0xf0, 0xf4, 0x89, 0x04, 0xbc, 0x96, 0xc4, 0x61, 0x0d, 0x38, + 0x5f, 0xfc, 0xf2, 0xe2, 0xf7, 0x01, 0x55, + ], + [ + 0x85, 0x45, 0x01, 0x67, 0xf0, 0x68, 0x54, 0xaf, 0xfa, 0x20, 0x7a, 0x83, 0xe4, + 0xfb, 0xa2, 0x36, 0xe6, 0x06, 0x72, 0xa7, 0x0e, 0x9b, 0xcf, 0xa9, 0x66, 0x48, + 0xc6, 0x6f, 0x35, 0xb5, 0x93, 0x3d, + ], + [ + 0x81, 0x90, 0xe3, 0x36, 0x41, 0xd8, 0xba, 0x97, 0x45, 0x49, 0xce, 0x9e, 0x76, + 0x11, 0xdc, 0x7e, 0x9d, 0x9d, 0x79, 0x31, 0xc7, 0xa2, 0x94, 0xba, 0x18, 0x75, + 0xfc, 0x7f, 0x68, 0x99, 0x49, 0x93, 0x87, 0xe8, 0x98, 0x94, 0xe2, 0x93, 0x93, + 0x6f, 0x1f, 0xa7, 0xfa, 0x06, 0x45, 0x61, 0x9d, 0x08, + ], + [ + 0x8e, 0x70, 0x56, 0x7e, 0x99, 0x0a, 0x3d, 0xcc, 0x62, 0x5a, 0x22, 0x4c, 0x7c, + 0x4f, 0x41, 0xf2, 0xef, 0x4e, 0xbc, 0x7f, 0x4d, 0xe1, 0x75, 0xaf, 0xf6, 0x2e, + 0xe3, 0x22, 0x40, 0x3d, 0x04, 0xe8, 0xff, 0xf9, 0x89, 0x5c, 0xa7, 0xdf, 0x90, + 0xcc, 0x1b, 0x44, 0x4a, 0x61, 0xe6, 0x25, 0x28, 0x43, 0x41, 0xfb, 0x95, 0x60, + 0xb7, 0x42, 0x71, 0x9b, 0x3d, 0x76, 0x6e, 0x05, 0x9a, 0xdc, 0x32, 0x95, + ] + ), + test_case!( + [ + 0xb5, 0x14, 0x6d, 0x49, 0x4c, 0xa9, 0x01, 0xfc, 0x77, 0x8f, 0x03, 0x8e, 0x97, + 0x88, 0x9c, 0x42, 0x8e, 0x9e, 0x4a, 0x69, 0x04, 0x83, 0x6f, 0x04, 0x43, 0xd7, + 0x1b, 0x26, 0x68, 0xed, 0xef, 0x3d, 0x59, 0x1a, 0xbd, 0x32, 0x05, 0x3f, 0x66, + 0x94, 0x4c, 0x92, 0x31, 0x51, 0xcd, 0xa3, 0xaa, 0xde, 0xe9, 0xf2, 0x57, 0xf3, + 0xb4, 0x06, 0x0c, 0xf1, 0xc3, 0x4e, 0x11, 0x78, 0x21, 0x56, 0x30, 0xfb, 0xd1, + 0xc8, 0x59, 0x14, 0xfc, 0x49, 0xeb, 0xf0, 0xf7, 0x57, 0x8c, 0xb3, 0xae, 0x8f, + 0x5c, 0x77, 0xb0, 0x31, 0xe7, 0x44, 0x75, 0x37, 0x78, 0x59, 0x99, 0x80, 0x0b, + 0x9d, 0x65, 0x21, 0x2d, 0xc2, 0x08, 0x8c, 0x42, 0xf6, 0x47, 0x66, 0x2d, 0x3c, + 0xb9, 0x20, 0x0a, 0xdc, 0x58, + ], + [ + 0x8c, 0x13, 0x3b, 0x86, 0x53, 0x53, 0x53, 0x8e, 0x8c, 0x14, 0x29, 0x75, 0xbf, + 0x4b, 0xb3, 0x9f, 0xa7, 0x47, 0xee, 0x43, + ], + [ + 0xfc, 0x6b, 0x1c, 0x1d, 0x9b, 0x7f, 0xb5, 0x4b, 0xf0, 0x24, 0x6b, 0x5e, 0x08, + 0x1e, 0x8e, 0xe9, 0x7c, 0x0f, 0xc0, 0x9c, 0xfc, 0x5b, 0x64, 0x3e, 0xb7, 0x0b, + 0x17, 0x8b, 0xe4, 0xcb, 0x6e, 0x57, + ], + [ + 0x41, 0xb7, 0x43, 0xa2, 0xe3, 0x7c, 0xee, 0x23, 0x5f, 0x7e, 0xbb, 0x99, 0x5d, + 0x20, 0xcd, 0x64, 0x1e, 0x58, 0x9d, 0x3d, 0x64, 0x8f, 0x1d, 0xaf, 0xc0, 0x8e, + 0xa7, 0x1b, 0x9d, 0x46, 0x39, 0x51, 0x4b, 0xf6, 0xf5, 0x36, 0xa7, 0x27, 0x69, + 0x34, 0xc6, 0x33, 0x2a, 0x76, 0xdd, 0x1c, 0xe9, 0x86, + ], + [ + 0x61, 0x6b, 0xdd, 0xe7, 0x6b, 0x81, 0xa1, 0x1f, 0x23, 0xd2, 0xe8, 0x86, 0xe9, + 0x84, 0x6b, 0x17, 0x11, 0x64, 0x54, 0x54, 0x1a, 0x75, 0xb8, 0xf5, 0xc0, 0xa5, + 0x57, 0x46, 0x87, 0x80, 0x2c, 0xcf, 0xda, 0x37, 0xff, 0xea, 0xde, 0xbb, 0xac, + 0x3b, 0xb6, 0x26, 0xd4, 0xf3, 0x40, 0x11, 0x86, 0xea, 0xe6, 0x8c, 0x79, 0xeb, + 0x50, 0x5b, 0xa2, 0x76, 0x79, 0xb4, 0x3e, 0x55, 0x6d, 0x3a, 0xcd, 0xcf, + ] + ), + test_case!( + [ + 0xf1, 0xea, 0x8d, 0x82, 0x6d, 0x9b, 0xe3, 0xd7, 0x78, 0x2c, 0x7d, 0x5b, 0xca, + 0x2d, 0x4a, 0x63, 0x44, 0x8c, 0xa2, 0x1b, 0xf6, 0x3c, 0xb7, 0x0e, 0x3c, 0x35, + 0x92, 0x9a, 0x16, 0xe3, 0xd3, 0x47, 0x9a, 0xc8, 0xcd, 0x98, 0x6d, 0x7b, 0x9d, + 0xaf, 0xb5, 0x01, 0x91, 0x18, 0x70, 0x58, 0x1d, 0xba, 0x9f, 0x80, 0xdf, 0x3c, + 0x92, 0xc1, 0x4d, 0x66, 0x0a, 0xec, 0x73, 0x00, 0xdb, 0x2c, 0x8d, 0x0d, 0x7e, + 0xe1, 0x8a, 0x90, 0x7a, 0x20, 0xf2, 0xe6, 0xbf, 0x00, 0x08, 0xbd, 0xee, 0x92, + 0x95, 0xa9, 0x3c, 0xdb, 0x11, 0x01, 0x8f, 0x92, 0x8d, 0xc2, 0xdb, 0x9f, 0xe1, + 0x81, 0xb6, 0x4f, 0x73, 0xdd, 0x67, 0x3e, 0x8d, 0x0b, 0xb9, 0x32, 0xfd, 0x47, + 0xab, 0x0d, 0xdf, 0x9b, 0xcb, 0x1d, + ], + [ + 0x41, 0x7b, 0xa5, 0xc8, 0x71, 0xe8, 0x44, 0x75, 0xe4, 0x26, 0x7e, 0x08, 0x6f, + 0x2e, 0x4e, 0xe5, 0xc8, 0x53, 0xcc, 0x8e, + ], + [ + 0x3e, 0x14, 0x86, 0xd7, 0x1e, 0x1d, 0xf3, 0xd6, 0x94, 0x28, 0xf9, 0x7a, 0x31, + 0xf4, 0x3a, 0x61, 0x08, 0x5b, 0x39, 0xc1, 0x6d, 0xf4, 0x24, 0x94, 0xd5, 0x4d, + 0x99, 0x42, 0xad, 0x5b, 0xd3, 0x92, + ], + [ + 0x4f, 0x96, 0xad, 0xe7, 0x50, 0x21, 0x99, 0xbd, 0xba, 0xe4, 0x03, 0xd3, 0x28, + 0x53, 0x0c, 0x38, 0xd4, 0xca, 0x4f, 0x03, 0x8d, 0xea, 0x0d, 0x38, 0x93, 0xbd, + 0xe7, 0x2e, 0xbd, 0xc3, 0xaa, 0xab, 0x1b, 0xb8, 0xe6, 0xd4, 0x8a, 0x93, 0x2a, + 0x39, 0x8e, 0x3d, 0x96, 0x8c, 0xab, 0x00, 0x2d, 0x0c, + ], + [ + 0x40, 0x9a, 0x8a, 0x20, 0xd8, 0x6d, 0x0b, 0x2f, 0x82, 0x90, 0x50, 0xd1, 0x8a, + 0x1d, 0xb3, 0x80, 0x25, 0x5a, 0xbd, 0xf4, 0xc7, 0x0d, 0xb3, 0xa0, 0x8e, 0xfc, + 0xde, 0x96, 0x40, 0x27, 0xd4, 0x64, 0x79, 0x60, 0x98, 0xd0, 0xcb, 0xf5, 0x53, + 0x7b, 0xdf, 0x2d, 0x32, 0xdf, 0x7c, 0x5b, 0x09, 0xec, 0x7f, 0x7a, 0x08, 0x41, + 0x1c, 0x4e, 0x3b, 0x2d, 0x59, 0x67, 0xc3, 0x25, 0xce, 0x5e, 0x91, 0x45, + ] + ), + test_case!( + [ + 0xa4, 0x18, 0x9d, 0xfd, 0x9a, 0x35, 0x34, 0xe4, 0x73, 0x63, 0x36, 0xd3, 0xf3, + 0x95, 0x7f, 0x49, 0x2b, 0x8f, 0x02, 0xa0, 0x5d, 0xa5, 0x10, 0xd1, 0x56, 0x4e, + 0xb0, 0xa6, 0x99, 0xb1, 0xf5, 0x4d, 0x30, 0xab, 0x82, 0xf1, 0x48, 0xbf, 0x6f, + 0x01, 0x42, 0x3c, 0x1e, 0xba, 0xad, 0xc5, 0x66, 0x9a, 0xe4, 0xe1, 0x60, 0xd1, + 0x56, 0x7f, 0x2f, 0x16, 0xdf, 0xe7, 0x5e, 0x52, 0xee, 0xe6, 0x59, 0x2b, 0x99, + 0x41, 0x29, 0xa8, 0xa1, 0x4c, 0xe7, 0x97, 0x07, 0x22, 0x30, 0x34, 0x07, 0x82, + 0x0d, 0x20, 0xb9, 0xcb, 0xa0, 0x39, 0xaa, 0x38, 0x00, 0xf9, 0xcf, 0x02, 0xe8, + 0xc3, 0x4b, 0xb6, 0xee, 0x62, 0x54, 0x6c, 0xbd, 0x08, 0xe8, 0xab, 0xe3, 0x51, + 0x09, 0x32, 0x1b, 0xe7, 0xe8, 0x37, 0x7c, + ], + [ + 0x2b, 0x2f, 0x47, 0x4c, 0x74, 0xe9, 0x54, 0x25, 0xa4, 0x02, 0xd4, 0xf3, 0xa4, + 0xba, 0x04, 0x4e, 0x6d, 0x4d, 0x8b, 0xf1, + ], + [ + 0xd4, 0xb2, 0xa8, 0x5d, 0xff, 0x21, 0xc8, 0x17, 0xeb, 0x40, 0xb2, 0xd6, 0x3f, + 0xbd, 0x3a, 0xf2, 0x42, 0xb1, 0x13, 0x04, 0x05, 0x94, 0xf8, 0x5c, 0xce, 0x69, + 0x82, 0x5c, 0x98, 0x54, 0xb6, 0x0d, + ], + [ + 0x6e, 0xad, 0xbc, 0x38, 0x81, 0xa6, 0x3f, 0x8e, 0xed, 0xe1, 0x71, 0x72, 0xc1, + 0x79, 0xd8, 0xa9, 0xf9, 0x4e, 0x9d, 0x0a, 0x48, 0x1d, 0x55, 0xfc, 0xbd, 0xc2, + 0xdf, 0x71, 0xd0, 0x9b, 0x19, 0x06, 0xf0, 0xf5, 0x07, 0x4f, 0x12, 0x5b, 0x45, + 0xd5, 0x45, 0xa2, 0xdf, 0x0c, 0x15, 0xd4, 0x03, 0xa0, + ], + [ + 0xaa, 0x0d, 0x5e, 0x4c, 0xc6, 0x9e, 0x85, 0x47, 0x30, 0x67, 0xdb, 0x63, 0xe9, + 0xed, 0x74, 0x6e, 0x11, 0x33, 0x02, 0xf1, 0xd0, 0xa8, 0x9f, 0xb9, 0x81, 0x49, + 0x88, 0x2b, 0x37, 0x04, 0x2a, 0x53, 0xd7, 0x1d, 0x2f, 0x9f, 0xdc, 0xe0, 0x00, + 0x8f, 0x0c, 0xe5, 0x74, 0x1e, 0x48, 0x73, 0x4f, 0x14, 0x07, 0x93, 0x3e, 0x24, + 0xed, 0xea, 0x58, 0x7a, 0x72, 0xbb, 0xce, 0x99, 0xb6, 0x85, 0xa8, 0x04, + ] + ), + test_case!( + [ + 0xe1, 0x66, 0x54, 0x9d, 0x89, 0xba, 0x1a, 0x92, 0x89, 0x90, 0x82, 0xac, 0x46, + 0x27, 0xb2, 0xb3, 0x04, 0x5d, 0x9a, 0xef, 0x4e, 0x0c, 0xe2, 0x7a, 0xe8, 0xdd, + 0xda, 0xb7, 0x16, 0x87, 0x58, 0xf7, 0x25, 0xcb, 0x23, 0xfc, 0x59, 0x23, 0x4f, + 0x8f, 0x40, 0x44, 0x75, 0xff, 0x7a, 0xcd, 0x6c, 0x41, 0x74, 0x39, 0x00, 0xad, + 0xca, 0x50, 0xff, 0x91, 0x77, 0x16, 0xe5, 0x05, 0x02, 0xc2, 0x21, 0x08, 0x81, + 0x50, 0x5d, 0x0a, 0xd7, 0x9b, 0x41, 0xe4, 0x48, 0x4e, 0x19, 0xd4, 0xe8, 0x6c, + 0xca, 0x99, 0xf3, 0x81, 0xc9, 0xa6, 0x0f, 0x62, 0x23, 0x53, 0x43, 0x35, 0x40, + 0x53, 0x34, 0xc6, 0xa2, 0xf2, 0x81, 0x54, 0xe2, 0xb5, 0x33, 0xf3, 0x18, 0x61, + 0x4d, 0x76, 0xe1, 0xe4, 0xa9, 0xaf, 0x86, 0xaf, + ], + [ + 0x12, 0xf0, 0x89, 0x09, 0x46, 0xed, 0xac, 0x56, 0x44, 0x72, 0x73, 0x8e, 0xd2, + 0x7f, 0x22, 0x2e, 0x28, 0xbb, 0x8f, 0x67, + ], + [ + 0xc8, 0x90, 0x61, 0xa1, 0x10, 0x1d, 0xaa, 0xed, 0x5d, 0x84, 0xaa, 0xe7, 0xbc, + 0x16, 0x4e, 0x75, 0xcf, 0x14, 0x4e, 0x65, 0x0c, 0x43, 0xc1, 0x7a, 0xc4, 0x47, + 0x40, 0x01, 0x51, 0x8a, 0x9d, 0x9c, + ], + [ + 0x07, 0xfa, 0x94, 0x07, 0x67, 0xe9, 0x1f, 0xbd, 0x03, 0x21, 0x98, 0xe3, 0x55, + 0xaf, 0x8b, 0x17, 0xcd, 0xfe, 0xad, 0x99, 0x39, 0x67, 0x80, 0xb4, 0x52, 0xf6, + 0x4b, 0x71, 0x92, 0x8a, 0xc2, 0x90, 0x5c, 0x54, 0x9d, 0xcc, 0xee, 0xa1, 0x5e, + 0x88, 0xe7, 0x6e, 0xb9, 0x8e, 0xb5, 0xfd, 0x03, 0x86, + ], + [ + 0x4d, 0x1e, 0x52, 0xd8, 0xdc, 0x7b, 0x67, 0x3f, 0xe4, 0xa1, 0x03, 0x79, 0xf1, + 0xfe, 0x76, 0xb0, 0xfc, 0x82, 0xe3, 0x75, 0x00, 0x2c, 0x85, 0x80, 0xf7, 0xa8, + 0x53, 0x32, 0x8f, 0xae, 0x3d, 0xeb, 0xd3, 0x7a, 0xd8, 0xa2, 0xe0, 0x1a, 0x4c, + 0x0a, 0x79, 0x6e, 0x7c, 0x06, 0x44, 0x0f, 0x87, 0x71, 0x38, 0x07, 0x61, 0x91, + 0x79, 0x34, 0xbb, 0x0e, 0xf2, 0x48, 0x45, 0x8f, 0x8c, 0xfb, 0x4a, 0x01, + ] + ), + test_case!( + [ + 0x4a, 0x53, 0xae, 0x9f, 0xa6, 0x30, 0xa1, 0x42, 0x37, 0xb2, 0x8f, 0x03, 0xa6, + 0xfa, 0x1d, 0x67, 0x72, 0xda, 0xbd, 0xd1, 0xa9, 0x0f, 0xcc, 0x6c, 0xbd, 0x40, + 0xa9, 0xf3, 0x3b, 0x76, 0x6d, 0x4c, 0x1e, 0x91, 0x9c, 0x5b, 0x65, 0xf5, 0x43, + 0xcb, 0x07, 0x50, 0x90, 0x5c, 0x89, 0xb2, 0xcc, 0x25, 0xff, 0xf4, 0x20, 0xf2, + 0x7c, 0x81, 0x52, 0x49, 0x39, 0xf1, 0xc1, 0x66, 0x3d, 0xf8, 0xed, 0x07, 0xd8, + 0xf9, 0xb1, 0x9a, 0x50, 0x0e, 0x8a, 0xe9, 0xdc, 0x5b, 0xdd, 0xb4, 0xda, 0x74, + 0xb1, 0x8c, 0xf2, 0xf0, 0x2c, 0xb3, 0x6a, 0x78, 0x7a, 0x44, 0x1d, 0x2f, 0x7c, + 0xa4, 0x8b, 0x7b, 0x3e, 0xd6, 0x14, 0x6f, 0x36, 0xfe, 0xdc, 0x37, 0x00, 0xe4, + 0x3b, 0xb8, 0xbe, 0x0c, 0x7f, 0x05, 0xa3, 0x17, 0xb6, + ], + [ + 0x9b, 0xa1, 0x42, 0x6a, 0xff, 0x8a, 0xad, 0xf4, 0x58, 0x32, 0xee, 0x84, 0x43, + 0x92, 0x5d, 0xc1, 0x67, 0x21, 0x73, 0x99, + ], + [ + 0x09, 0xed, 0x65, 0x34, 0xf7, 0x07, 0xe8, 0xb0, 0x70, 0x84, 0xf2, 0x79, 0xee, + 0x4b, 0xf0, 0x96, 0x14, 0xa4, 0x43, 0xee, 0xdc, 0xd1, 0xbe, 0x5e, 0xe9, 0x27, + 0x50, 0x07, 0xb5, 0x0b, 0xeb, 0xa7, + ], + [ + 0x5e, 0xff, 0x39, 0x41, 0x0c, 0xb0, 0xce, 0x63, 0x87, 0xe3, 0xb7, 0x2b, 0xe7, + 0xf1, 0xa2, 0x9e, 0xf8, 0x5f, 0xa4, 0x2e, 0xc8, 0x6b, 0x3a, 0x44, 0x69, 0xce, + 0xa6, 0x42, 0x94, 0x6e, 0x2b, 0x18, 0x2b, 0x6f, 0xdf, 0x9f, 0x2e, 0x5d, 0x71, + 0xf7, 0xf3, 0x3e, 0xb6, 0x7f, 0xce, 0x39, 0x95, 0x83, + ], + [ + 0x6b, 0xc8, 0x6e, 0x6a, 0xac, 0xcc, 0x3a, 0x5f, 0xe8, 0x56, 0x92, 0x7b, 0x3a, + 0xf0, 0x51, 0x4c, 0xbc, 0x14, 0x3f, 0x1b, 0x1d, 0xd8, 0x05, 0x48, 0x9e, 0x00, + 0x21, 0xfa, 0xfb, 0x7f, 0xaa, 0xd2, 0x7c, 0xd8, 0x92, 0x22, 0x79, 0x08, 0x99, + 0xf9, 0xe4, 0x06, 0x05, 0x2e, 0x54, 0x62, 0xcc, 0x0d, 0x7c, 0xdf, 0x8c, 0x07, + 0x25, 0xca, 0x3d, 0x11, 0xa0, 0xec, 0x0e, 0x06, 0x23, 0x42, 0x97, 0xb8, + ] + ), + test_case!( + [ + 0x76, 0xd7, 0x3d, 0x4f, 0x69, 0xdc, 0x8c, 0x5c, 0xf5, 0xb6, 0x67, 0x9c, 0x21, + 0x46, 0x5c, 0x96, 0x9a, 0xcf, 0x70, 0x93, 0xa7, 0x5e, 0xa9, 0x10, 0x6e, 0xaa, + 0x97, 0xa7, 0xee, 0x4b, 0xaf, 0x22, 0xb8, 0xaf, 0x17, 0x53, 0xe6, 0xb9, 0x24, + 0x44, 0x74, 0xb0, 0x46, 0xc9, 0xd0, 0x4b, 0xdc, 0xa8, 0xb7, 0x0f, 0x40, 0xf1, + 0xac, 0xea, 0x50, 0xfe, 0x29, 0x5b, 0x3e, 0x5d, 0xc5, 0x03, 0x95, 0xc2, 0x7c, + 0x86, 0xe2, 0x5d, 0x6f, 0x96, 0x42, 0xae, 0x78, 0x59, 0xeb, 0xde, 0xb5, 0xa8, + 0x3b, 0x1c, 0xed, 0x22, 0x69, 0x20, 0xef, 0x40, 0x49, 0xff, 0xa0, 0x67, 0x99, + 0xf6, 0x8b, 0x5e, 0xb9, 0x03, 0x04, 0xcb, 0x6e, 0x7d, 0x73, 0x55, 0xd1, 0x11, + 0xe1, 0xed, 0xe7, 0xf7, 0xfc, 0xd3, 0xb2, 0x6b, 0xdc, 0x60, + ], + [ + 0x48, 0xab, 0xed, 0x0a, 0x34, 0x1e, 0xdb, 0x52, 0x91, 0xad, 0xb4, 0xfd, 0x6e, + 0x8d, 0xf4, 0x56, 0x69, 0x20, 0x12, 0x2a, + ], + [ + 0x74, 0x3d, 0x94, 0xca, 0x8b, 0xad, 0x40, 0x3d, 0x7f, 0x35, 0xaa, 0x18, 0xb2, + 0x38, 0xad, 0x2d, 0x99, 0x90, 0x82, 0xe7, 0x1a, 0x0f, 0x53, 0xe2, 0x3f, 0x59, + 0x21, 0xfa, 0x3b, 0x33, 0x37, 0x18, + ], + [ + 0x89, 0xbf, 0x09, 0xe1, 0xac, 0xcc, 0xb8, 0x0e, 0xf9, 0x5d, 0x8b, 0x2f, 0x96, + 0x17, 0x11, 0x6c, 0x45, 0x83, 0xcb, 0x01, 0xfb, 0xcb, 0x0a, 0xb5, 0x17, 0xef, + 0xdf, 0x3f, 0x26, 0x2a, 0x07, 0xbb, 0x3e, 0x8b, 0xf3, 0x7a, 0x4f, 0x48, 0xe1, + 0x26, 0x34, 0x65, 0x0b, 0x6d, 0x8a, 0x5b, 0x6a, 0xed, + ], + [ + 0x7b, 0x85, 0x82, 0xb1, 0x7d, 0xd2, 0x72, 0x1f, 0xc9, 0x05, 0xc7, 0xda, 0xd0, + 0x89, 0x97, 0xff, 0xe6, 0x28, 0xdc, 0xfe, 0x92, 0x7f, 0x12, 0xde, 0xef, 0x36, + 0x83, 0xc6, 0x10, 0x77, 0x39, 0xfb, 0xf3, 0x2a, 0xbd, 0x04, 0xed, 0x33, 0x7d, + 0xb1, 0x76, 0x3e, 0xc7, 0x93, 0x8e, 0x12, 0x0d, 0x66, 0xd9, 0x33, 0x76, 0xf7, + 0x90, 0xe3, 0x27, 0xa3, 0x21, 0xbc, 0xde, 0x93, 0x2f, 0x83, 0x73, 0xe0, + ] + ), + test_case!( + [ + 0x42, 0xdc, 0x01, 0xc6, 0x21, 0x6f, 0x63, 0xc4, 0xd7, 0x90, 0xe0, 0xdc, 0x4a, + 0xf0, 0xe8, 0x01, 0x96, 0x97, 0x00, 0x8a, 0x8b, 0xd6, 0x6e, 0x45, 0x0b, 0x3c, + 0x09, 0xa5, 0x7f, 0xe8, 0x1e, 0xa7, 0x56, 0x2f, 0x0a, 0x56, 0x59, 0x0c, 0xe5, + 0x21, 0xb8, 0xe9, 0x18, 0x50, 0x03, 0xb6, 0xbf, 0x8c, 0x65, 0xc9, 0xd1, 0x95, + 0x81, 0x1e, 0xa4, 0xa8, 0x0e, 0xec, 0x86, 0x27, 0xe4, 0x55, 0xe9, 0xe8, 0x2f, + 0xf0, 0xfa, 0x95, 0xfc, 0xe8, 0x4a, 0x0d, 0x31, 0x0e, 0x7b, 0x8a, 0xda, 0xf2, + 0xd6, 0x24, 0x8a, 0x60, 0x2f, 0x5e, 0x42, 0x9b, 0x3d, 0xc2, 0x67, 0x6d, 0x6b, + 0x82, 0x1f, 0x9e, 0x2e, 0x8d, 0x89, 0xf6, 0xc3, 0xe9, 0x21, 0x66, 0x6d, 0xf1, + 0x8f, 0x88, 0x03, 0xbe, 0xfe, 0xa2, 0xdf, 0x5d, 0x5d, 0xd7, 0x4e, + ], + [ + 0x87, 0xd1, 0x06, 0xff, 0x32, 0xef, 0x61, 0xfc, 0xbf, 0x4e, 0x1e, 0x03, 0xad, + 0xe0, 0x7a, 0x92, 0x66, 0x43, 0xeb, 0x70, + ], + [ + 0x5a, 0xc0, 0x1f, 0x00, 0xf8, 0xf9, 0x0b, 0x30, 0x06, 0x10, 0xe0, 0xf8, 0xfb, + 0x4e, 0xae, 0x3e, 0xad, 0x3d, 0xd8, 0xaf, 0x65, 0xa4, 0xae, 0xe6, 0xd6, 0x6d, + 0x6c, 0xc9, 0x48, 0x12, 0xe6, 0x13, + ], + [ + 0x7e, 0xf3, 0x75, 0xab, 0xc5, 0x4a, 0x89, 0xe0, 0x89, 0xb5, 0x02, 0x7a, 0xda, + 0x3c, 0xac, 0x91, 0x59, 0xe7, 0xb7, 0xcd, 0x24, 0xfd, 0x8a, 0x7c, 0xf0, 0x78, + 0xa3, 0xea, 0xfa, 0x49, 0x9d, 0x9d, 0x90, 0x13, 0x27, 0x5b, 0x26, 0x6e, 0x57, + 0xd7, 0x89, 0xe3, 0x4a, 0x05, 0xf0, 0xb7, 0xc6, 0x14, + ], + [ + 0xb7, 0x57, 0x73, 0xe3, 0x87, 0xc1, 0x44, 0xe5, 0x59, 0xd4, 0xb6, 0x1a, 0x3c, + 0x21, 0x82, 0x0e, 0xd4, 0x76, 0xd1, 0x53, 0x3e, 0x12, 0xa7, 0x0c, 0x24, 0xd3, + 0xf6, 0x35, 0xee, 0xfe, 0x06, 0xcb, 0xb9, 0xea, 0x50, 0x89, 0x61, 0x69, 0x4a, + 0x34, 0x26, 0x6c, 0xec, 0x3a, 0x08, 0x8e, 0x5e, 0x21, 0xc9, 0x41, 0x31, 0x45, + 0x09, 0x04, 0xb1, 0x16, 0x44, 0x47, 0xa1, 0x83, 0x23, 0xae, 0x41, 0xe0, + ] + ), + test_case!( + [ + 0xff, 0xfb, 0xcd, 0x72, 0x05, 0x36, 0xe0, 0xbf, 0x38, 0x8a, 0xeb, 0xe0, 0xb7, + 0x48, 0xeb, 0xc2, 0x51, 0xac, 0xd6, 0xd3, 0xe3, 0x10, 0xbe, 0x8e, 0x79, 0x95, + 0xd0, 0x36, 0x37, 0x94, 0xed, 0x56, 0x2e, 0x3a, 0x09, 0x0a, 0x52, 0x0d, 0xb5, + 0x03, 0xd2, 0xd5, 0xcb, 0xcf, 0x21, 0x32, 0x4c, 0x57, 0xed, 0x74, 0x15, 0x7f, + 0xd6, 0x84, 0x8f, 0xc5, 0x0f, 0x14, 0xb0, 0x49, 0xc8, 0x1d, 0xbf, 0x29, 0x9a, + 0xa5, 0x42, 0x32, 0x10, 0x0f, 0x39, 0x68, 0x0f, 0x5b, 0x06, 0xdc, 0x04, 0x09, + 0xbb, 0x22, 0x7d, 0xe6, 0x46, 0x8a, 0x6c, 0xfb, 0x1d, 0xe3, 0xd6, 0x14, 0x50, + 0xb6, 0x77, 0xc2, 0x0a, 0x09, 0xb2, 0x10, 0xe5, 0xf2, 0xe2, 0x3d, 0x1f, 0xe5, + 0x75, 0xbc, 0xa6, 0xaa, 0xa5, 0x27, 0xa6, 0x38, 0xae, 0xf2, 0x0d, 0x87, + ], + [ + 0x6d, 0x88, 0x3b, 0x25, 0xb1, 0xa3, 0xf5, 0xcc, 0xae, 0xd8, 0xea, 0xa5, 0xd6, + 0xa6, 0xb3, 0x9d, 0xa4, 0xd8, 0x9a, 0xf0, + ], + [ + 0x32, 0x02, 0xf4, 0xd0, 0xb4, 0x18, 0x76, 0x4b, 0x1f, 0x92, 0x7f, 0xcf, 0xcf, + 0x21, 0x08, 0x58, 0xaa, 0x13, 0xc6, 0x11, 0xd1, 0x5f, 0x47, 0x8f, 0xf1, 0x00, + 0x5c, 0xa3, 0x29, 0x60, 0x1d, 0x8c, + ], + [ + 0xf2, 0x0e, 0xd9, 0x4c, 0xbe, 0x00, 0xa6, 0x3b, 0x11, 0x48, 0x08, 0xc2, 0x72, + 0xd7, 0xa7, 0x07, 0x2f, 0xbb, 0xf8, 0xcb, 0x14, 0x58, 0xa1, 0xc7, 0x62, 0x78, + 0x23, 0x06, 0x58, 0x84, 0xe9, 0x51, 0xd8, 0x9c, 0xf4, 0xc8, 0xad, 0xb1, 0xed, + 0x09, 0x81, 0xbb, 0x1b, 0x2b, 0xde, 0x5c, 0x8a, 0x49, + ], + [ + 0xc7, 0x27, 0x9d, 0x89, 0x51, 0x15, 0xfc, 0x29, 0x9b, 0x2c, 0x78, 0x24, 0x22, + 0xdf, 0xe2, 0x8e, 0x23, 0x28, 0xd1, 0xd6, 0x29, 0x5b, 0x6f, 0x24, 0xcb, 0x2d, + 0xbb, 0xc5, 0xea, 0xbb, 0xce, 0xf7, 0x8d, 0xde, 0x95, 0xe4, 0x2c, 0x63, 0x69, + 0x88, 0x51, 0x2f, 0xe5, 0x19, 0x9e, 0xbf, 0xd2, 0x91, 0xab, 0x1e, 0x9a, 0x11, + 0xa3, 0x3e, 0xfe, 0x0d, 0x68, 0xf1, 0xc3, 0xb6, 0xe2, 0xd2, 0xcb, 0x26, + ] + ), + test_case!( + [ + 0xda, 0x98, 0x3b, 0x70, 0x4a, 0x7d, 0x30, 0x39, 0x41, 0x43, 0xca, 0x08, 0x31, + 0xf0, 0xfe, 0x8d, 0x07, 0x26, 0x08, 0x78, 0x82, 0xa6, 0x73, 0x4a, 0xcc, 0x5e, + 0xa3, 0xc4, 0x77, 0xbb, 0xbf, 0x70, 0x6f, 0x36, 0x4a, 0x49, 0xac, 0xb4, 0xc0, + 0xc3, 0x28, 0xbd, 0x7f, 0xfd, 0xf6, 0x24, 0x7d, 0x81, 0x2e, 0xc4, 0xcb, 0x5b, + 0x95, 0xb6, 0x68, 0x70, 0xaf, 0x5e, 0x14, 0xf6, 0x2c, 0x3e, 0xda, 0xa6, 0x6f, + 0xc5, 0x6a, 0x53, 0xde, 0x32, 0x22, 0x88, 0xe6, 0x0d, 0x84, 0x22, 0x78, 0x41, + 0x42, 0x85, 0x43, 0xe0, 0x19, 0x1b, 0x05, 0xeb, 0x44, 0xc0, 0x19, 0xf5, 0xb6, + 0x36, 0xd2, 0xbb, 0x28, 0x9f, 0x24, 0x4b, 0x35, 0x4d, 0xfe, 0x1f, 0x18, 0x8c, + 0x55, 0x5f, 0x7b, 0x75, 0x94, 0xfa, 0x72, 0xd7, 0x1d, 0xc5, 0xd5, 0x0c, 0xf1, + ], + [ + 0x6c, 0x39, 0xee, 0xef, 0xb9, 0xbc, 0x44, 0x19, 0x69, 0x90, 0x7a, 0xf8, 0xe2, + 0x99, 0x0f, 0xda, 0x64, 0x5f, 0xd5, 0x1e, + ], + [ + 0x71, 0x1d, 0x8f, 0x4d, 0xbe, 0x0c, 0xf0, 0xa5, 0x9a, 0x1a, 0x15, 0xcc, 0x2d, + 0xa7, 0x78, 0xcf, 0xfc, 0xe1, 0xba, 0x0c, 0xc3, 0x9e, 0xf3, 0x32, 0xb9, 0xa3, + 0x85, 0x1c, 0x96, 0xd9, 0xe9, 0xb2, + ], + [ + 0x8b, 0x68, 0x75, 0xa4, 0x97, 0x19, 0x9e, 0x08, 0x98, 0xe0, 0x43, 0x57, 0x25, + 0xcb, 0x8a, 0xef, 0xcb, 0x32, 0x1b, 0x11, 0x30, 0x5d, 0x4d, 0xb4, 0xfc, 0xf0, + 0xfe, 0xc5, 0xff, 0xe0, 0x6f, 0x45, 0x7e, 0x91, 0xaa, 0xb0, 0x57, 0x0c, 0x37, + 0xe5, 0xdd, 0x95, 0xc5, 0x25, 0x67, 0x96, 0x09, 0x3d, + ], + [ + 0x76, 0xa7, 0x57, 0xe1, 0x06, 0x7e, 0x3e, 0xfe, 0x97, 0xd0, 0x72, 0x06, 0x6a, + 0xab, 0x5c, 0x70, 0xa1, 0x2e, 0xa6, 0x51, 0x2c, 0x17, 0x18, 0x07, 0xad, 0xae, + 0xd4, 0xda, 0x27, 0x64, 0x03, 0x5b, 0xa7, 0x9e, 0xeb, 0xaf, 0x85, 0xe2, 0x88, + 0x47, 0xef, 0xd7, 0x10, 0x26, 0x2a, 0x47, 0xe0, 0xb3, 0x61, 0xdc, 0xbe, 0xf5, + 0x9a, 0x76, 0xc2, 0x28, 0x72, 0x7f, 0x5d, 0x88, 0x07, 0x6e, 0xf7, 0x63, + ] + ), + test_case!( + [ + 0x9d, 0xd4, 0x85, 0x38, 0x98, 0x21, 0xf8, 0x31, 0x9d, 0x8f, 0x41, 0x82, 0x9d, + 0x3b, 0xad, 0x47, 0x7e, 0x57, 0xd8, 0x88, 0x55, 0xff, 0xdf, 0x60, 0x25, 0xe4, + 0x97, 0xdf, 0x36, 0x71, 0x3f, 0x8c, 0xa2, 0x11, 0x45, 0x53, 0xf6, 0x01, 0xa0, + 0x18, 0xcd, 0x08, 0x34, 0xb4, 0xdc, 0x25, 0x68, 0xbe, 0x26, 0x2d, 0x6b, 0x74, + 0x11, 0x24, 0x26, 0x9c, 0x24, 0xbb, 0xa7, 0x0a, 0x88, 0xf3, 0x47, 0x5c, 0xfe, + 0x0b, 0xb8, 0x32, 0x6a, 0x64, 0x04, 0x0c, 0xa8, 0x18, 0xf9, 0x86, 0x0a, 0x14, + 0x15, 0x2b, 0x18, 0x6b, 0x19, 0x6b, 0xf7, 0xe6, 0x06, 0xff, 0xfc, 0xf8, 0xf2, + 0x59, 0xf6, 0x06, 0x1b, 0x69, 0x8d, 0xf0, 0xb4, 0x42, 0x96, 0x80, 0x3c, 0xad, + 0x30, 0x1c, 0xfd, 0x4c, 0x85, 0xe0, 0x97, 0xe7, 0xbc, 0x99, 0x52, 0x5b, 0x6a, + 0xc1, + ], + [ + 0xae, 0x01, 0x87, 0x69, 0xd0, 0x5b, 0x04, 0xc4, 0x92, 0x37, 0x4d, 0x4d, 0xa8, + 0x5f, 0x99, 0x73, 0x64, 0xf9, 0x09, 0x2c, + ], + [ + 0xa1, 0xd7, 0xf6, 0x13, 0x56, 0xb8, 0xae, 0xda, 0xbd, 0x85, 0x37, 0xe3, 0x29, + 0x0a, 0x97, 0x5f, 0x7c, 0x21, 0x4c, 0xf5, 0x1c, 0xba, 0xeb, 0x5a, 0x16, 0xde, + 0x10, 0x91, 0xc4, 0x5b, 0xad, 0xba, + ], + [ + 0x61, 0x0c, 0xc7, 0x8a, 0xc5, 0xa9, 0x88, 0x51, 0x72, 0xf9, 0x00, 0xb2, 0x45, + 0xcf, 0xed, 0x09, 0x61, 0xf9, 0xb6, 0x3d, 0x50, 0xb9, 0xe4, 0xbe, 0x49, 0x47, + 0xeb, 0xc6, 0x71, 0xb6, 0xd9, 0xf6, 0x72, 0xf8, 0xf3, 0xc4, 0x30, 0x60, 0x38, + 0xff, 0x28, 0xdf, 0xb8, 0x74, 0x65, 0x79, 0xbd, 0xad, + ], + [ + 0x51, 0xd5, 0xbd, 0x85, 0x91, 0x64, 0x55, 0xdb, 0x2e, 0x7f, 0xaa, 0xb2, 0xef, + 0xe7, 0xef, 0x03, 0x8b, 0x94, 0xf2, 0x1e, 0x05, 0x76, 0xe3, 0x4d, 0xbe, 0x59, + 0xcd, 0xce, 0xd2, 0xe1, 0xc2, 0xe3, 0xf6, 0xda, 0xea, 0xd1, 0x5f, 0x00, 0x13, + 0x6a, 0x46, 0x1e, 0xd7, 0xf3, 0x5e, 0xc6, 0x8c, 0xb7, 0x90, 0xc1, 0xbd, 0x79, + 0xcf, 0x5b, 0xa4, 0xc9, 0x5a, 0xa2, 0x5d, 0x82, 0xd0, 0x4b, 0xae, 0xac, + ] + ), + test_case!( + [ + 0x4c, 0x09, 0x85, 0x45, 0x82, 0x76, 0xb4, 0xff, 0x7e, 0x31, 0x8c, 0xa9, 0xf0, + 0x80, 0xda, 0x0c, 0x7f, 0x83, 0xc5, 0x55, 0x61, 0x52, 0xbe, 0xdc, 0x75, 0x53, + 0x7c, 0x14, 0x25, 0xfd, 0xa7, 0x52, 0x49, 0xe3, 0xf4, 0x7f, 0xcf, 0x93, 0x6b, + 0xf9, 0xe0, 0x45, 0x0a, 0xbd, 0xeb, 0xf6, 0x88, 0x3e, 0x0f, 0x64, 0xea, 0xf2, + 0xe5, 0x73, 0x2d, 0x67, 0x09, 0x21, 0xa1, 0x8c, 0xdc, 0xf7, 0xe1, 0xfd, 0x5d, + 0xb3, 0x4b, 0xd5, 0x06, 0xfc, 0x65, 0x3d, 0x4f, 0xd6, 0xf0, 0x74, 0x77, 0xc6, + 0x11, 0xfd, 0x6a, 0x46, 0x05, 0x29, 0x69, 0x52, 0x89, 0x53, 0xf8, 0x3a, 0xcf, + 0xdc, 0xd5, 0x26, 0x10, 0xf7, 0xab, 0x17, 0x50, 0x6a, 0x96, 0x50, 0x45, 0xc2, + 0x2e, 0xf9, 0x1b, 0x3e, 0xdb, 0x85, 0x0a, 0x9e, 0xa1, 0xd4, 0x59, 0x84, 0x2b, + 0xc1, 0x40, + ], + [ + 0xf1, 0xa9, 0x90, 0x89, 0xd5, 0x24, 0x2e, 0x1d, 0x7c, 0x91, 0x19, 0x5d, 0x5a, + 0x8b, 0x55, 0x74, 0xf3, 0xfe, 0xfe, 0x2f, + ], + [ + 0xe7, 0xdb, 0xb4, 0xcc, 0x82, 0xb4, 0x60, 0xc2, 0xe5, 0x65, 0x87, 0x7f, 0x80, + 0xcf, 0x3a, 0xfc, 0xa0, 0xcb, 0x2a, 0xf9, 0xe4, 0xfa, 0x7b, 0x0f, 0x9d, 0x55, + 0x3a, 0x50, 0xfc, 0x2c, 0x0c, 0x6f, + ], + [ + 0x52, 0xd4, 0xff, 0x43, 0x7e, 0xc9, 0x7e, 0x3f, 0xee, 0xbe, 0x46, 0x14, 0xe3, + 0xc3, 0xde, 0x1d, 0xa0, 0xe7, 0x7a, 0x56, 0x94, 0x8e, 0xb4, 0x20, 0xe9, 0xbe, + 0x88, 0xa4, 0x2b, 0xc1, 0xb5, 0x10, 0x17, 0xea, 0x72, 0x44, 0x98, 0xe7, 0x24, + 0xba, 0xb7, 0xf7, 0x49, 0xf9, 0xe2, 0x6d, 0x0f, 0xa8, + ], + [ + 0x47, 0x18, 0x39, 0xb3, 0xf1, 0xf5, 0x8a, 0x2f, 0x17, 0x01, 0x21, 0x28, 0xdf, + 0xd2, 0xe1, 0x3f, 0x47, 0xea, 0xb5, 0xe5, 0x8d, 0xef, 0xe9, 0xcd, 0x1e, 0xab, + 0x84, 0xed, 0x90, 0xa1, 0xc4, 0x24, 0x85, 0x0b, 0xc7, 0x18, 0xe8, 0xe0, 0x73, + 0xcd, 0x71, 0x30, 0xfd, 0xdb, 0x47, 0xad, 0x39, 0x8f, 0xf4, 0x1b, 0xe3, 0xe3, + 0x22, 0x7e, 0x4e, 0x0b, 0x51, 0x5d, 0xdb, 0x4b, 0xd0, 0x01, 0x76, 0xbf, + ] + ), + test_case!( + [ + 0x11, 0x82, 0xce, 0xe5, 0x78, 0xce, 0x8e, 0xc7, 0x8d, 0x79, 0xb7, 0xbe, 0x18, + 0xac, 0x02, 0x60, 0xce, 0x98, 0x4b, 0xa8, 0xa3, 0xe6, 0x83, 0xee, 0x1f, 0x11, + 0x1a, 0xb8, 0xba, 0x5f, 0x83, 0x5b, 0x55, 0x7b, 0x2b, 0xe4, 0x97, 0x50, 0x69, + 0xa1, 0x62, 0x40, 0xf8, 0x59, 0xce, 0x03, 0xb6, 0x4a, 0x2f, 0xe6, 0xba, 0x71, + 0x90, 0xad, 0xa0, 0x34, 0xe3, 0x65, 0xc5, 0x90, 0x5c, 0x35, 0xbd, 0x63, 0x71, + 0x4f, 0xc4, 0xf6, 0x1e, 0xa7, 0x8f, 0x16, 0x34, 0x8c, 0x3d, 0x89, 0x5c, 0x0a, + 0x03, 0x5a, 0x29, 0x18, 0x30, 0x24, 0x1a, 0xfd, 0x03, 0xf1, 0x40, 0x05, 0xdf, + 0x3b, 0xd8, 0xa7, 0xb4, 0xfb, 0x5b, 0xc2, 0xf0, 0x6f, 0x8c, 0x16, 0x39, 0x1a, + 0x0f, 0x8e, 0x90, 0xc4, 0x1f, 0xdb, 0x10, 0xdd, 0x58, 0xaf, 0x4c, 0x23, 0x2b, + 0x86, 0xc6, 0xa7, + ], + [ + 0x8f, 0xd6, 0x1c, 0x8e, 0xf7, 0xf3, 0xa5, 0x72, 0xc6, 0x2e, 0x28, 0x12, 0x79, + 0x35, 0xaf, 0x4c, 0x22, 0xfb, 0xcf, 0x51, + ], + [ + 0x36, 0xcc, 0xa0, 0x29, 0xd4, 0x41, 0xb4, 0x5a, 0xd5, 0x38, 0x10, 0xc8, 0x6c, + 0xce, 0x07, 0x45, 0x91, 0x91, 0x52, 0x2b, 0xf4, 0x0e, 0x14, 0xf2, 0x69, 0xad, + 0xf4, 0x4d, 0x8e, 0xa7, 0xf7, 0x3f, + ], + [ + 0x83, 0x95, 0x5a, 0xe5, 0x4b, 0xa7, 0x52, 0x97, 0xb1, 0xa9, 0x34, 0x8d, 0xcf, + 0xd3, 0x56, 0x66, 0x6e, 0x95, 0xe9, 0x54, 0x97, 0xec, 0xa3, 0xd4, 0xed, 0xe4, + 0x30, 0x71, 0x49, 0x82, 0xa3, 0x77, 0x5b, 0xcd, 0xd8, 0x44, 0xaf, 0x98, 0x0b, + 0x34, 0x6e, 0x8a, 0x3f, 0xbe, 0x7c, 0xaf, 0x35, 0x82, + ], + [ + 0x06, 0xb0, 0xb7, 0xb4, 0xe0, 0x84, 0xf9, 0xd5, 0x7c, 0xb8, 0x37, 0x8b, 0x56, + 0x3d, 0xcb, 0x6e, 0xc9, 0xc9, 0xa5, 0xf7, 0x8d, 0x30, 0xea, 0x23, 0x67, 0x7b, + 0x65, 0x3e, 0x07, 0xef, 0x64, 0xee, 0x7e, 0x95, 0x23, 0x78, 0xea, 0x34, 0x5b, + 0x86, 0xc2, 0x49, 0x88, 0x93, 0x30, 0xa4, 0xa7, 0xd0, 0x1c, 0x0e, 0x94, 0xd9, + 0x35, 0x57, 0x73, 0x82, 0xd1, 0x9b, 0x6f, 0x5e, 0xa8, 0xd3, 0x30, 0x22, + ] + ), + test_case!( + [ + 0xf2, 0xb5, 0xe5, 0xe6, 0x7c, 0x23, 0x99, 0x48, 0xa0, 0x21, 0x8f, 0xbd, 0x4c, + 0xe4, 0xbb, 0x16, 0x6c, 0xa3, 0x9d, 0x84, 0xf7, 0x5c, 0x8b, 0x20, 0x15, 0x95, + 0xf4, 0x81, 0x4d, 0x7a, 0x09, 0xa2, 0xd1, 0xdb, 0xbf, 0x0e, 0x09, 0x46, 0xfa, + 0xfa, 0xed, 0x1f, 0x36, 0xe6, 0x0f, 0xc4, 0x3c, 0x8c, 0xb7, 0x0d, 0x95, 0xc9, + 0xd8, 0x05, 0x0a, 0x44, 0x7c, 0x59, 0x8c, 0x43, 0x12, 0xf1, 0x80, 0xd4, 0xdb, + 0x6e, 0xc9, 0xc3, 0xa8, 0x99, 0xdd, 0x8b, 0xd9, 0x4e, 0xea, 0xff, 0x60, 0x52, + 0x11, 0xb5, 0x53, 0xee, 0x6f, 0x7d, 0x93, 0x68, 0x3a, 0x55, 0x71, 0x41, 0xcc, + 0xd0, 0x08, 0x05, 0xaa, 0x91, 0x12, 0x94, 0x98, 0x69, 0xac, 0xd2, 0x58, 0x2c, + 0x8e, 0x73, 0x04, 0x6e, 0xd0, 0xf0, 0xe3, 0x1b, 0x5d, 0xd1, 0x84, 0x81, 0x1d, + 0xa4, 0xd6, 0x26, 0xb8, + ], + [ + 0xf5, 0x3c, 0x07, 0x5c, 0x04, 0xdc, 0x6c, 0xee, 0x71, 0xcd, 0x1c, 0xd4, 0xee, + 0x57, 0x69, 0x05, 0x21, 0x72, 0xc3, 0xad, + ], + [ + 0xaf, 0x4c, 0x8f, 0xf9, 0x6b, 0xf4, 0xe7, 0xc7, 0x13, 0xff, 0x59, 0x35, 0x2b, + 0x51, 0x35, 0xa4, 0x8c, 0xf4, 0xca, 0xc3, 0xb1, 0x56, 0xc1, 0xce, 0x09, 0x48, + 0x7c, 0x70, 0xd4, 0x2c, 0x03, 0x38, + ], + [ + 0xd5, 0xb5, 0xf4, 0x47, 0xa6, 0xe3, 0xb4, 0xf1, 0xd7, 0x66, 0x71, 0x27, 0x4e, + 0x7d, 0xc2, 0x07, 0x98, 0xfb, 0x3d, 0x72, 0x38, 0xce, 0xf1, 0xd5, 0xf0, 0x75, + 0x36, 0xc1, 0x5d, 0xde, 0x71, 0x56, 0x9b, 0x8d, 0x04, 0xd2, 0xc4, 0x0d, 0x17, + 0xfc, 0x8d, 0x8d, 0xa5, 0xc9, 0x6a, 0xac, 0x5b, 0xf9, + ], + [ + 0x11, 0x4f, 0xeb, 0x01, 0xba, 0xe2, 0x8d, 0x03, 0xfd, 0x28, 0x56, 0x5c, 0x4d, + 0x29, 0x40, 0xdc, 0x57, 0xf6, 0x19, 0xbe, 0x98, 0x37, 0x70, 0xa0, 0x63, 0x07, + 0x06, 0x3a, 0x42, 0x68, 0x34, 0x55, 0x36, 0xf7, 0x0f, 0x12, 0x0d, 0x1e, 0x49, + 0xf3, 0x0d, 0x35, 0xa4, 0x27, 0x5a, 0xa4, 0xf6, 0x02, 0x57, 0x84, 0x48, 0xb4, + 0xfc, 0x39, 0xcb, 0x32, 0x34, 0xc7, 0x55, 0xec, 0xfb, 0xcf, 0x45, 0x6a, + ] + ), + test_case!( + [ + 0xd2, 0x36, 0xf4, 0x62, 0x69, 0x1b, 0x68, 0x21, 0x7a, 0xc4, 0x6a, 0xf3, 0x0e, + 0x1d, 0x09, 0xb9, 0xb6, 0x64, 0xc4, 0x8c, 0x11, 0x5a, 0xf8, 0x7a, 0xcc, 0x0d, + 0x3a, 0x0e, 0xd8, 0x28, 0xb6, 0xb1, 0xd4, 0xcc, 0x3d, 0xa9, 0xa2, 0xf6, 0x4b, + 0xd7, 0xc9, 0x8b, 0xed, 0xc3, 0xcc, 0xde, 0x83, 0x6d, 0xfd, 0x53, 0x94, 0xd1, + 0xbe, 0xa8, 0x7a, 0xcc, 0x0b, 0x27, 0xd6, 0x4a, 0xfa, 0x38, 0x4c, 0x11, 0x9b, + 0xa1, 0x80, 0x9f, 0xc3, 0xfc, 0xcd, 0xb3, 0x92, 0x88, 0x06, 0xbf, 0x66, 0x26, + 0x55, 0xa6, 0x0e, 0x1b, 0x25, 0x9c, 0x2b, 0xf4, 0x9d, 0x50, 0xf0, 0x9a, 0x15, + 0xa9, 0x55, 0x5a, 0xe5, 0x0d, 0x02, 0x8c, 0xf3, 0x7d, 0x9d, 0x2c, 0xfc, 0x00, + 0xdb, 0xf0, 0x98, 0x0d, 0xec, 0x35, 0x14, 0x8c, 0xc6, 0xed, 0x14, 0xc7, 0x4e, + 0xe7, 0x16, 0xbe, 0xb5, 0x0a, + ], + [ + 0x06, 0xa5, 0xff, 0xb3, 0x35, 0xd0, 0x97, 0xca, 0x04, 0x6c, 0xd9, 0xcf, 0x8e, + 0x1c, 0x99, 0x6b, 0x5f, 0xe4, 0x8e, 0x07, + ], + [ + 0x62, 0x1a, 0xe4, 0xc7, 0x4e, 0x8e, 0x18, 0x91, 0x14, 0xa8, 0x8c, 0x01, 0x76, + 0x99, 0x4a, 0x85, 0x67, 0xc7, 0x41, 0x58, 0x05, 0xde, 0xf4, 0xaf, 0x65, 0x99, + 0x62, 0x44, 0xb3, 0x21, 0x4a, 0x22, + ], + [ + 0xac, 0x59, 0x70, 0xe8, 0xb0, 0x53, 0xa7, 0x6f, 0xf6, 0x15, 0x6e, 0xb6, 0xb7, + 0x80, 0xfe, 0xea, 0x6f, 0x1d, 0xff, 0x25, 0x75, 0xd1, 0x80, 0x49, 0x46, 0xbc, + 0xcc, 0x36, 0xd2, 0xa9, 0x82, 0xdf, 0x72, 0x55, 0xc8, 0x9d, 0x7c, 0x80, 0x6e, + 0x1e, 0xf8, 0x6d, 0x55, 0x4b, 0x31, 0xbf, 0xd6, 0xfc, + ], + [ + 0x11, 0x4f, 0x70, 0x33, 0x2f, 0xf7, 0x1c, 0xc8, 0xa6, 0x9c, 0x91, 0x72, 0x4b, + 0xbf, 0x1c, 0x4e, 0x2c, 0x61, 0x05, 0x79, 0x36, 0xea, 0xd8, 0x84, 0x11, 0x5a, + 0xb0, 0x1f, 0x98, 0x4c, 0xe1, 0x7d, 0x0b, 0xb6, 0x7b, 0xec, 0xbc, 0x0b, 0x91, + 0x40, 0x5d, 0x86, 0xe4, 0x28, 0x52, 0x2b, 0x62, 0x8c, 0xcf, 0x9d, 0x63, 0xe2, + 0xb1, 0xf3, 0x8a, 0xd7, 0x6d, 0x7b, 0x4f, 0xd9, 0x82, 0x28, 0x6d, 0x6c, + ] + ), + test_case!( + [ + 0xf0, 0x31, 0x92, 0xdd, 0x53, 0xed, 0x8c, 0x16, 0xd8, 0x98, 0xf6, 0xd0, 0xf1, + 0x5c, 0xad, 0xff, 0xf0, 0x4b, 0x8e, 0x6f, 0xc9, 0x5c, 0xb7, 0xc3, 0x16, 0xa1, + 0x2e, 0x15, 0xd5, 0x4f, 0x52, 0x6f, 0xaf, 0x4c, 0x14, 0xfb, 0x09, 0x18, 0xf8, + 0xb7, 0x76, 0x71, 0x6c, 0xd4, 0x7c, 0xd5, 0x69, 0x06, 0x31, 0x1f, 0x45, 0xce, + 0x9d, 0x1c, 0xfc, 0x2e, 0x14, 0xbb, 0x42, 0x1c, 0x6c, 0x12, 0x9a, 0x1c, 0xb9, + 0xac, 0x03, 0x04, 0x27, 0xc4, 0x87, 0x84, 0x2d, 0x64, 0xb5, 0x33, 0x5c, 0xf1, + 0x8c, 0xdf, 0x4a, 0x64, 0x71, 0x9d, 0xff, 0x1c, 0xd2, 0x60, 0xcd, 0x69, 0x1b, + 0x22, 0x30, 0x7f, 0x5c, 0x3b, 0x93, 0x97, 0x7b, 0xab, 0x7c, 0x54, 0xc8, 0xfa, + 0x8b, 0xde, 0x24, 0x7a, 0x0d, 0x86, 0x44, 0x67, 0xb0, 0xde, 0x8e, 0xde, 0xfc, + 0xd7, 0x24, 0xa4, 0xe5, 0x2d, 0x74, + ], + [ + 0xe6, 0xe4, 0x77, 0xb9, 0xd7, 0x69, 0x8f, 0x64, 0x36, 0x03, 0x8a, 0x41, 0xab, + 0x63, 0xe4, 0x8c, 0x12, 0x13, 0x77, 0x74, + ], + [ + 0xba, 0xef, 0xe7, 0x1a, 0xc5, 0x1e, 0xe0, 0x9e, 0x72, 0x9d, 0xfb, 0x7a, 0xad, + 0x90, 0xb4, 0x7c, 0x66, 0xb4, 0x48, 0xcc, 0xdf, 0xc5, 0xa4, 0x04, 0x2e, 0x67, + 0xf3, 0x33, 0x82, 0x8b, 0xab, 0x47, + ], + [ + 0x56, 0xab, 0x79, 0x45, 0x8b, 0x2a, 0x28, 0xa9, 0x02, 0xf1, 0x03, 0x08, 0xd0, + 0x95, 0x43, 0x97, 0x4d, 0x2f, 0x2f, 0x7b, 0xd3, 0x7a, 0x58, 0x9d, 0x2b, 0xca, + 0x77, 0x06, 0x81, 0xbd, 0xf0, 0x03, 0xef, 0x18, 0x96, 0x6b, 0xb6, 0xec, 0x76, + 0x92, 0x22, 0xd2, 0x20, 0x4d, 0x94, 0x16, 0xc7, 0x3f, + ], + [ + 0xe5, 0x52, 0x60, 0x65, 0x88, 0x60, 0x2e, 0x87, 0x4a, 0xf6, 0xe6, 0x3b, 0x58, + 0x28, 0xa6, 0x98, 0x84, 0x5d, 0x6f, 0xe3, 0xbf, 0x6f, 0x4a, 0x4a, 0x86, 0xcd, + 0x49, 0xad, 0xcb, 0xe9, 0xbc, 0xf8, 0x79, 0x73, 0x64, 0x45, 0x99, 0x1f, 0xbe, + 0xd5, 0x69, 0x09, 0x44, 0xa5, 0xb8, 0x55, 0xae, 0x71, 0x63, 0x9c, 0x85, 0x8b, + 0xbe, 0x0a, 0xa9, 0x3e, 0xfd, 0xdb, 0xcd, 0xda, 0x03, 0xb8, 0xe6, 0xd8, + ] + ), + test_case!( + [ + 0xf7, 0x9c, 0x30, 0x50, 0xb6, 0x40, 0xb4, 0x7c, 0x71, 0x25, 0x3a, 0xa3, 0xb5, + 0xf1, 0x5a, 0x26, 0x8c, 0xaf, 0x3c, 0xc3, 0xe5, 0x5d, 0x18, 0x85, 0x6d, 0xf5, + 0x37, 0x26, 0x8f, 0x64, 0x00, 0xd5, 0x1e, 0x90, 0xbe, 0x84, 0xc7, 0x56, 0xfa, + 0x9b, 0xcf, 0xc9, 0x9d, 0x5c, 0x50, 0x1b, 0x44, 0xbf, 0x63, 0x25, 0xbf, 0xe3, + 0x0d, 0xd9, 0xea, 0xd3, 0x97, 0xc2, 0xfd, 0xd7, 0x86, 0x61, 0xb7, 0xbd, 0x15, + 0x2f, 0xa8, 0x16, 0xe9, 0x2f, 0xca, 0x16, 0x41, 0x6b, 0xbb, 0x05, 0x59, 0xfa, + 0x84, 0xcb, 0xf6, 0x00, 0xc9, 0xb9, 0xc6, 0xe6, 0x3e, 0x52, 0x68, 0x83, 0x7c, + 0x99, 0x53, 0x2e, 0x14, 0x98, 0xcf, 0x16, 0xe3, 0x80, 0xb7, 0x3c, 0x3f, 0x00, + 0x1d, 0xe4, 0xd6, 0x6c, 0x5c, 0x0b, 0x5f, 0xe0, 0xa4, 0x8d, 0x89, 0x9d, 0x6a, + 0x44, 0xa0, 0x75, 0x73, 0x59, 0xbf, 0xce, + ], + [ + 0x18, 0x12, 0x5f, 0xe5, 0xef, 0xac, 0x2e, 0xd0, 0x6e, 0x37, 0x28, 0xb1, 0xfd, + 0x34, 0xa2, 0xe7, 0xca, 0xcb, 0xac, 0xa9, + ], + [ + 0x63, 0x79, 0x63, 0xe9, 0xed, 0xbb, 0x5c, 0xaa, 0xec, 0xe1, 0xf1, 0xd1, 0xe3, + 0x5c, 0xa9, 0x95, 0x60, 0xe1, 0x05, 0x4c, 0xc5, 0x56, 0x28, 0x2f, 0x99, 0xf3, + 0x14, 0xb6, 0x18, 0xcc, 0x4e, 0x30, + ], + [ + 0xb1, 0xd0, 0xaf, 0xf6, 0xee, 0xbd, 0xde, 0x45, 0xd7, 0xfa, 0x0b, 0x9a, 0x10, + 0x3a, 0x78, 0xf8, 0xf0, 0xef, 0xdd, 0x24, 0x90, 0x7b, 0x3b, 0x25, 0x1a, 0x78, + 0x43, 0xc7, 0x17, 0x01, 0xbf, 0x01, 0x57, 0xaa, 0xfc, 0x61, 0x09, 0x53, 0xba, + 0x0c, 0x02, 0x3a, 0x99, 0x38, 0xb0, 0xd0, 0x71, 0x04, + ], + [ + 0x02, 0xce, 0x26, 0x11, 0xb3, 0x4b, 0x1c, 0x3b, 0x1d, 0x62, 0xca, 0xcf, 0x17, + 0x07, 0xf5, 0xbd, 0x12, 0x60, 0xd0, 0x30, 0x89, 0xa9, 0xb4, 0x74, 0x5b, 0xb3, + 0xa3, 0x7d, 0xb8, 0xec, 0xdb, 0xd2, 0x1d, 0x00, 0x6a, 0x62, 0x50, 0x0f, 0x54, + 0xf4, 0x67, 0x8c, 0x47, 0x19, 0x0d, 0x02, 0x02, 0x0e, 0x22, 0x30, 0xd8, 0xcd, + 0x39, 0xd8, 0xa5, 0x4c, 0x2a, 0x32, 0x11, 0xfa, 0x3e, 0x09, 0x1e, 0xd0, + ] + ), + test_case!( + [ + 0x18, 0x8d, 0xb6, 0x50, 0xe7, 0xc6, 0x52, 0x64, 0xd8, 0x2d, 0x85, 0xd3, 0x01, + 0x9c, 0xbd, 0xd1, 0xe9, 0xe8, 0x2d, 0x52, 0x13, 0xee, 0x20, 0x0c, 0x4d, 0x83, + 0xe0, 0x05, 0xd1, 0x9e, 0x52, 0x8a, 0xea, 0xe2, 0x7c, 0x3c, 0xa5, 0x4c, 0x92, + 0x94, 0x6a, 0x39, 0x0a, 0x2d, 0xf5, 0x35, 0x16, 0xc1, 0x89, 0xe8, 0x16, 0xc5, + 0x3e, 0x29, 0xe6, 0xc6, 0xa1, 0x9f, 0xcc, 0xb3, 0x13, 0x51, 0xa5, 0xec, 0xc2, + 0x91, 0x94, 0x42, 0x64, 0xcf, 0x1b, 0xba, 0x9e, 0xc3, 0x89, 0x96, 0x9a, 0x81, + 0x2d, 0xb5, 0x04, 0xb0, 0xe3, 0xb3, 0xaf, 0x70, 0x0a, 0x20, 0x87, 0xde, 0x2f, + 0x7c, 0x01, 0xaa, 0x05, 0xa0, 0xe2, 0x6f, 0xd8, 0x68, 0x48, 0x94, 0x93, 0xa1, + 0x77, 0xe8, 0xd3, 0x8d, 0x1c, 0x09, 0x54, 0x10, 0x17, 0x21, 0xee, 0x4d, 0xbd, + 0x3b, 0xfb, 0x1a, 0xb6, 0xd7, 0x53, 0x7f, 0xf2, + ], + [ + 0xc1, 0xb6, 0xed, 0x84, 0x79, 0xda, 0xa9, 0xc2, 0x06, 0xf0, 0x9c, 0xbf, 0x85, + 0xaf, 0xed, 0x82, 0x1f, 0xd6, 0x97, 0x01, + ], + [ + 0x80, 0x5d, 0xdf, 0x7f, 0x0c, 0xfb, 0x96, 0x44, 0x4f, 0x26, 0xe4, 0x87, 0xa0, + 0x55, 0x94, 0x25, 0x68, 0x4f, 0x2d, 0x55, 0x1f, 0x67, 0x03, 0x7a, 0xd0, 0xcd, + 0x32, 0x13, 0x49, 0x3b, 0x1f, 0x35, + ], + [ + 0x8c, 0xa5, 0x66, 0x01, 0xe5, 0x6e, 0xd6, 0x2e, 0x5b, 0x59, 0x46, 0x25, 0xa2, + 0xbd, 0xfa, 0xc7, 0xac, 0xf6, 0x03, 0x0b, 0x3f, 0xa0, 0xe9, 0x1f, 0x37, 0xba, + 0xbe, 0x1b, 0x57, 0x0c, 0xf8, 0xca, 0xb6, 0x36, 0xf7, 0x9b, 0x51, 0xf7, 0xa8, + 0xa9, 0x77, 0x9e, 0x42, 0x61, 0xeb, 0x20, 0x60, 0x42, + ], + [ + 0x60, 0xea, 0x72, 0x81, 0x0f, 0x3e, 0xd4, 0xf7, 0x36, 0x0b, 0xd5, 0x63, 0x14, + 0xb8, 0x66, 0xef, 0xb2, 0x26, 0xd8, 0x86, 0x0e, 0x7a, 0x03, 0xd0, 0xdf, 0x97, + 0x88, 0xd9, 0x0f, 0xbb, 0x49, 0xaa, 0xbb, 0x83, 0x77, 0xbc, 0x6c, 0x09, 0x0d, + 0xd8, 0xaa, 0xb8, 0x89, 0xcd, 0x27, 0x12, 0xb2, 0xe3, 0xbc, 0x73, 0x83, 0xf2, + 0x55, 0xaa, 0x78, 0xb1, 0x66, 0x0f, 0x9e, 0xcf, 0xf1, 0x02, 0x1d, 0x71, + ] + ), + test_case!( + [ + 0xa1, 0xb5, 0x83, 0x1e, 0x1d, 0xb1, 0x48, 0x1e, 0x38, 0x07, 0x6d, 0x3c, 0x1f, + 0xa4, 0x1f, 0x32, 0x2c, 0xcc, 0x0e, 0xac, 0xa2, 0x98, 0x86, 0xad, 0x42, 0x49, + 0xa4, 0x7b, 0x66, 0x2f, 0x2a, 0xde, 0x40, 0xf6, 0xc1, 0x0f, 0xe4, 0xfe, 0x96, + 0x08, 0x7a, 0xb4, 0x98, 0x06, 0x38, 0x07, 0x51, 0x52, 0x0b, 0xe9, 0x4c, 0x87, + 0x6b, 0xa0, 0x3f, 0x5b, 0xe3, 0x7e, 0x95, 0xfc, 0xa3, 0xe9, 0xad, 0xf1, 0x0b, + 0x1c, 0xfd, 0x85, 0x26, 0x4f, 0xf6, 0x1e, 0x1c, 0xa3, 0x9c, 0x71, 0x50, 0x91, + 0x62, 0x69, 0x22, 0x35, 0x40, 0x11, 0xfc, 0x71, 0x62, 0xfd, 0xcc, 0xc1, 0xcd, + 0x2b, 0x69, 0x2f, 0x0f, 0x77, 0x7e, 0x61, 0x4a, 0xf2, 0x34, 0x1e, 0x73, 0x1a, + 0xa7, 0xb5, 0xaf, 0x2f, 0x34, 0xb9, 0xdf, 0x49, 0xd0, 0x9e, 0x50, 0x53, 0x52, + 0x22, 0x47, 0x4b, 0x98, 0x45, 0x1b, 0x04, 0x82, 0x80, + ], + [ + 0xac, 0xc6, 0x74, 0x48, 0x75, 0xe7, 0x23, 0x48, 0x75, 0x67, 0x6d, 0x6d, 0x9e, + 0xc7, 0x56, 0x5b, 0x8b, 0x57, 0x7a, 0xeb, + ], + [ + 0x6f, 0xcf, 0x39, 0x76, 0xc5, 0x67, 0xdf, 0x53, 0xa7, 0xcb, 0x68, 0x78, 0x5d, + 0xbb, 0xa1, 0x51, 0xdf, 0xe8, 0xdd, 0x3c, 0x53, 0xc6, 0xa7, 0xad, 0xcd, 0x22, + 0x42, 0x27, 0x17, 0x58, 0x81, 0x21, + ], + [ + 0x48, 0x1e, 0x1d, 0x8d, 0xbd, 0xf1, 0x4c, 0x82, 0x2e, 0x3b, 0xcf, 0x93, 0xc2, + 0xcf, 0x59, 0xcc, 0xc3, 0x46, 0x64, 0x38, 0xa0, 0x75, 0x90, 0x8d, 0x18, 0xd2, + 0xb4, 0xb8, 0x37, 0x06, 0xd4, 0x47, 0x3f, 0x4f, 0xb9, 0xb0, 0x55, 0x7b, 0x27, + 0x4f, 0x7c, 0x79, 0xcf, 0xfa, 0x3b, 0x4f, 0x2b, 0xc5, + ], + [ + 0xab, 0xb8, 0x26, 0x0a, 0x70, 0x30, 0x88, 0xbb, 0xbb, 0x7d, 0x33, 0xa9, 0x19, + 0x2d, 0x82, 0x80, 0x5b, 0x3b, 0x68, 0x7b, 0x44, 0xb1, 0x81, 0x8a, 0xc7, 0x6b, + 0xb1, 0x49, 0xf2, 0x22, 0x49, 0x31, 0x0c, 0xf9, 0xb7, 0x03, 0xe8, 0xa5, 0xcf, + 0xcc, 0xd9, 0xad, 0xfe, 0xb3, 0x1c, 0x16, 0x9a, 0x0c, 0x2a, 0xb0, 0x4a, 0xda, + 0xaf, 0x1b, 0xe8, 0xb4, 0x70, 0xa6, 0x05, 0x54, 0xc2, 0x69, 0x23, 0x01, + ] + ), + test_case!( + [ + 0x4b, 0x27, 0xe8, 0xbb, 0xdd, 0x90, 0x84, 0x61, 0x55, 0x4d, 0x1b, 0xf9, 0xdb, + 0xb6, 0x0b, 0x9f, 0xb6, 0xd5, 0x71, 0x94, 0x2b, 0x33, 0x6a, 0x2e, 0xd6, 0xfb, + 0xe6, 0x2e, 0x79, 0xce, 0x6e, 0xfa, 0xb1, 0xe0, 0x66, 0x1e, 0xef, 0x1a, 0x37, + 0xa5, 0x69, 0x7f, 0x0b, 0x3b, 0xf0, 0x09, 0x02, 0x3e, 0x98, 0x86, 0x70, 0x6c, + 0x9c, 0x9b, 0x72, 0x2d, 0x12, 0x81, 0x84, 0xfb, 0xac, 0x83, 0x42, 0xf7, 0xb7, + 0x46, 0x53, 0x31, 0x2a, 0x40, 0xf9, 0x98, 0xae, 0x5b, 0x05, 0x88, 0xaf, 0xd6, + 0xc1, 0x8e, 0xb6, 0x6f, 0x59, 0x2c, 0xaa, 0x44, 0x54, 0x6c, 0xf8, 0x0e, 0x09, + 0x99, 0x61, 0xd6, 0xc7, 0x6b, 0xd0, 0xc0, 0x34, 0x10, 0x2b, 0x3f, 0x61, 0x58, + 0xb1, 0xad, 0x3d, 0xdf, 0x34, 0xea, 0x0d, 0xe5, 0x02, 0xda, 0x7c, 0xb5, 0xe6, + 0x98, 0xa5, 0x20, 0x52, 0xc0, 0xbc, 0xb9, 0x05, 0x77, 0x93, + ], + [ + 0x01, 0xfb, 0xc4, 0xd0, 0x5e, 0x7d, 0x64, 0x44, 0xb8, 0x70, 0xf9, 0x64, 0x71, + 0xbc, 0x2a, 0xa3, 0x37, 0xc7, 0x99, 0xf8, + ], + [ + 0xdf, 0x36, 0x1a, 0x31, 0xd1, 0x6a, 0x5f, 0xf9, 0x3c, 0x20, 0xa9, 0xc6, 0x18, + 0x80, 0xcc, 0x30, 0x30, 0x9c, 0x01, 0x4e, 0x2c, 0x08, 0xfd, 0x33, 0xf1, 0x48, + 0x66, 0x9e, 0x33, 0xe6, 0x36, 0xa3, + ], + [ + 0x70, 0x83, 0xb7, 0xa3, 0xb7, 0x1c, 0x52, 0x64, 0xec, 0xb3, 0x63, 0xc2, 0xee, + 0xcb, 0xa0, 0x57, 0xb5, 0x37, 0xcd, 0xc7, 0xc7, 0xdd, 0xf8, 0x3b, 0x21, 0x14, + 0x84, 0x2a, 0x65, 0xbb, 0x84, 0x91, 0x36, 0xde, 0x8b, 0x21, 0x36, 0x27, 0x12, + 0xf1, 0x28, 0xc9, 0xc8, 0x8a, 0x74, 0xdd, 0x7f, 0xb1, + ], + [ + 0x30, 0xd8, 0x56, 0xd2, 0xc6, 0x90, 0xa0, 0x53, 0x2d, 0x58, 0x6e, 0x21, 0x0c, + 0xbd, 0x92, 0x03, 0xda, 0x89, 0x75, 0x1c, 0x37, 0xd0, 0xda, 0x6d, 0xd1, 0x98, + 0x03, 0x80, 0x62, 0x93, 0xe2, 0xef, 0x4e, 0x77, 0xde, 0xa8, 0x9d, 0x4a, 0x63, + 0xef, 0xf0, 0x5e, 0x93, 0xcb, 0x39, 0xbf, 0x26, 0x73, 0xcb, 0x26, 0x98, 0xe5, + 0x64, 0x08, 0xff, 0x26, 0xcf, 0xfc, 0xa4, 0x4c, 0x88, 0x74, 0x5d, 0x95, + ] + ), + test_case!( + [ + 0x1a, 0x55, 0xe0, 0xb6, 0x41, 0x24, 0x2a, 0xed, 0x58, 0x88, 0x73, 0xee, 0x88, + 0x47, 0x3a, 0x98, 0x9d, 0x09, 0xad, 0x14, 0x60, 0xf8, 0x67, 0xd5, 0x77, 0xc0, + 0xa1, 0x5c, 0xa0, 0xfa, 0xaf, 0xee, 0x3d, 0x8b, 0xdc, 0xf5, 0xe4, 0x9e, 0x08, + 0xdb, 0xdf, 0x57, 0x1a, 0xcb, 0x0b, 0xab, 0x71, 0x5f, 0xfc, 0xef, 0xd3, 0x5d, + 0x11, 0x5a, 0xbd, 0x65, 0x37, 0x6e, 0xa4, 0x98, 0x53, 0x85, 0x75, 0xe8, 0x96, + 0x72, 0x64, 0xbe, 0x34, 0x9c, 0x4e, 0x4f, 0x22, 0x31, 0x10, 0x00, 0xf6, 0x46, + 0x65, 0x8b, 0xdc, 0x9e, 0x33, 0x9d, 0x5d, 0xe9, 0xa0, 0xc3, 0x1b, 0x98, 0xf8, + 0x81, 0x99, 0xba, 0xaa, 0xe5, 0xff, 0x3c, 0x2a, 0xd7, 0xc9, 0x80, 0x3a, 0x34, + 0x98, 0x67, 0x0e, 0xb9, 0x2e, 0x42, 0xa9, 0x8e, 0x82, 0xc1, 0xcb, 0x54, 0x87, + 0x44, 0x9b, 0xbf, 0x5f, 0x45, 0x19, 0xa0, 0x43, 0xe2, 0xb3, 0x41, + ], + [ + 0x81, 0xb5, 0x99, 0x54, 0xaf, 0x53, 0x79, 0xe9, 0x25, 0xb3, 0x20, 0xb5, 0x88, + 0x47, 0x1d, 0x99, 0x43, 0xad, 0x33, 0x61, + ], + [ + 0x15, 0xd6, 0xec, 0x09, 0xb8, 0xdc, 0xdd, 0xd9, 0x25, 0x55, 0x84, 0xf1, 0x81, + 0xab, 0xdd, 0xf5, 0x62, 0x4f, 0x3e, 0x3f, 0x8e, 0x34, 0x19, 0x8f, 0x14, 0x85, + 0xed, 0xd3, 0xb7, 0xc1, 0x31, 0x54, + ], + [ + 0x5a, 0xb0, 0x46, 0x17, 0x1b, 0x70, 0x20, 0x9c, 0xbc, 0x6c, 0x24, 0xfb, 0xd3, + 0x3e, 0x77, 0x3e, 0x52, 0x0c, 0x56, 0x75, 0x52, 0xa3, 0x12, 0x76, 0x69, 0xd3, + 0x0d, 0x38, 0x45, 0x41, 0x3c, 0x21, 0x86, 0xa8, 0x57, 0xba, 0xb5, 0xeb, 0x32, + 0x45, 0xec, 0x46, 0xd0, 0xa7, 0xcf, 0x5b, 0x17, 0x2c, + ], + [ + 0x6c, 0x5d, 0x94, 0x61, 0x1e, 0xe6, 0xcb, 0xa0, 0xda, 0xcf, 0xcf, 0xca, 0x7c, + 0x40, 0xba, 0xb2, 0x97, 0x0f, 0x8c, 0xbc, 0xd3, 0x6e, 0x60, 0x04, 0xa5, 0x64, + 0x61, 0xa0, 0xd3, 0x7d, 0x8b, 0x0a, 0x56, 0x4d, 0x53, 0xad, 0x5f, 0xdc, 0x5c, + 0x09, 0x73, 0x29, 0x0d, 0xdd, 0xf5, 0x32, 0xc1, 0x1e, 0xec, 0xf2, 0x43, 0xc4, + 0xd0, 0x93, 0x20, 0x20, 0xed, 0xd0, 0xa7, 0x0d, 0xcb, 0x3e, 0x46, 0xe3, + ] + ), + ]; + } +}
diff --git a/src/insecure.rs b/src/insecure.rs new file mode 100644 index 0000000..ef255b3 --- /dev/null +++ b/src/insecure.rs
@@ -0,0 +1,22 @@ +// Copyright 2018 Google LLC +// +// Use of this source code is governed by an MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT. + +//! WARNING: INSECURE CRYPTOGRAPHIC OPERATIONS. +//! +//! This module contains cryptographic operations which are considered insecure. +//! These operations should only be used for compatibility with legacy systems, +//! but never in new systems! + +#![deprecated(note = "insecure cryptographic operations")] + +#[allow(deprecated)] +pub use hash::insecure_sha1_digest::InsecureSha1Digest; +#[allow(deprecated)] +pub use hmac::insecure_hmac_sha1::InsecureHmacSha1; + +#[cfg(feature = "kdf")] +#[allow(deprecated)] +pub use kdf::insecure_pbkdf2_hmac_sha1::insecure_pbkdf2_hmac_sha1;
diff --git a/src/kdf.rs b/src/kdf.rs new file mode 100644 index 0000000..0d48ee8 --- /dev/null +++ b/src/kdf.rs
@@ -0,0 +1,136 @@ +// Copyright 2018 Google LLC +// +// Use of this source code is governed by an MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT. + +//! Key Derivation Functions (KDFs). +//! +//! KDFs are low-level primitives often used to construct higher-level +//! protocols. Unless you're sure that this is what you need, you should +//! probably be using something else. In particular: +//! - If you need password verification, see the [`password`] module. +//! +//! [`password`]: ::password + +use std::num::NonZeroU32; + +use boringssl; +use hash::Hasher; + +/// The PBKDF2 Key Derivation Function. +/// +/// `pbkdf2` computes `iter` iterations of PBKDF2 of `password` and `salt`, +/// using an HMAC based on the hash function `H`. It stores the result in +/// `out_key`. Note that PBKDF2 can produce variable-length output, so it will +/// always fill the entirety of `out_key` regardless of its length. +/// +/// PBKDF2 is defined in RSA Security LLC's Public Key Cryptography Standards #5 +/// (PKCS #5) v2.0. For details, see [RFC 2898 Section 5.2]. +/// +/// # Security +/// +/// While PBKDF2 can produce any amount of key output, the entropy of its output +/// is bounded by the internal state. Be careful that the output key has enough +/// entropy for your needs. See [RFC 2898 Appendix B.1] for a discussion on +/// calculating the effective entropy of PBKDF2. Also remember that new attacks +/// are sometimes discovered, and it is your responsibility to keep up with the +/// latest attacks; RFC 2898's analysis may not be valid forever! +/// +/// [RFC 2898 Section 5.2]: https://tools.ietf.org/html/rfc2898#section-5.2 +/// [RFC 2898 Appendix B.1]: https://tools.ietf.org/html/rfc2898#appendix-B.1 +#[must_use] +pub fn pbkdf2<H: Hasher>(password: &[u8], salt: &[u8], iters: NonZeroU32, out_key: &mut [u8]) { + // PKCS5_PBKDF2_HMAC can only fail on OOM or if iters is 0. + boringssl::pkcs5_pbkdf2_hmac(password, salt, iters.get(), &H::evp_md(), out_key).unwrap(); +} + +#[cfg(feature = "insecure")] +pub(crate) mod insecure_pbkdf2_hmac_sha1 { + use std::num::NonZeroU32; + + #[allow(deprecated)] + use hash::InsecureSha1; + use kdf::pbkdf2; + + /// INSECURE: The PBKDF2 Key Derivation Function over HMAC-SHA1. + /// + /// # Security + /// + /// PBKDF2-HMAC-SHA1 is considered insecure, and should only be used for + /// compatibility with legacy applications. + /// + /// # Behavior + /// + /// `pbkdf2_hmac_sha1` computes `iter` iterations of PBKDF2-HMAC-SHA1 of + /// `password` and `salt`. It stores the result in `out_key`. + /// + /// PBKDF2 is defined in RSA Security LLC's Public Key Cryptography + /// Standards #5 (PKCS #5) v2.0. For details, see [RFC 2898 Section 5.2]. + /// + /// # Further Security Considerations + /// + /// While PBKDF2 can produce any amount of key output, the entropy of its + /// output is bounded by the internal state. Be careful that the output key + /// has enough entropy for your needs. See [RFC 2898 Appendix B.1] for a + /// discussion on calculating the effective entropy of PBKDF2, but keep in + /// mind that SHA-1's insecurities may affect this analysis! Also remember + /// that new attacks are sometimes discovered, and it is your responsibility + /// to keep up with the latest attacks; RFC 2898's analysis may not be valid + /// forever! + /// + /// [RFC 2898 Section 5.2]: https://tools.ietf.org/html/rfc2898#section-5.2 + /// [RFC 2898 Appendix B.1]: https://tools.ietf.org/html/rfc2898#appendix-B.1 + #[must_use] + #[deprecated(note = "PBKDF2-HMAC-SHA1 is considered insecure")] + pub fn insecure_pbkdf2_hmac_sha1( + password: &[u8], salt: &[u8], iters: NonZeroU32, out_key: &mut [u8], + ) { + #[allow(deprecated)] + pbkdf2::<InsecureSha1>(password, salt, iters, out_key) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use hash::*; + + #[test] + fn test_smoke() { + for password_len in 0..8 { + for salt_len in 0..8 { + for iters in 1..8 { + for out_key_len in 0..8 { + fn test<H: Hasher>( + password_len: usize, salt_len: usize, iters: u32, out_key_len: usize, + ) { + let password = [0, 1, 2, 3, 4, 5, 6, 7]; + let salt = [0, 1, 2, 3, 4, 5, 6, 7]; + let mut out_key_0 = [0; 8]; + let mut out_key_1 = [0; 8]; + + pbkdf2::<H>( + &password[..password_len], + &salt[..salt_len], + NonZeroU32::new(iters).unwrap(), + &mut out_key_0[..out_key_len], + ); + pbkdf2::<H>( + &password[..password_len], + &salt[..salt_len], + NonZeroU32::new(iters).unwrap(), + &mut out_key_1[..out_key_len], + ); + assert_eq!(&out_key_0[..out_key_len], &out_key_1[..out_key_len]); + } + + test::<Sha256>(password_len, salt_len, iters, out_key_len); + test::<Sha384>(password_len, salt_len, iters, out_key_len); + test::<Sha512>(password_len, salt_len, iters, out_key_len); + } + } + } + } + } +}
diff --git a/src/lib.rs b/src/lib.rs new file mode 100644 index 0000000..468ee9b --- /dev/null +++ b/src/lib.rs
@@ -0,0 +1,167 @@ +// Copyright 2018 Google LLC +// +// Use of this source code is governed by an MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT. + +//! Cryptography in Rust. +//! +//! `mundane` is a Rust cryptography library backed by BoringSSL that is +//! difficult to misuse, ergonomic, and performant (in that order). +//! +//! # Features +//! +//! By default, `mundane` provides only high-level cryptographic primitives. +//! Unless you are implementing cryptographic protocols, these high-level +//! primitives should be all you need. However, if you are sure that you need +//! something lower level, `mundane` provides features to enable a number of +//! different low level primitives. +//! +//! WARNING: Being low level, these primitives provide the programmer with more +//! degrees of freedom. There are more conditions that the programmer must meet +//! in order to guarantee security, and thus more ways for the programmer to +//! shoot themself in the foot. Please only use these primitives if you're aware +//! of the risks and are comfortable with the responsibility of using them +//! correctly! +//! +//! **Features** +//! +//! | Name | Description | +//! | ------------ | ------------------------ | +//! | `kdf` | Key derivation functions | +//! | `rand-bytes` | Generate random bytes | +//! +//! # Insecure Operations +//! +//! `mundane` supports one additional feature not listed in the previous +//! section: `insecure`. This enables some cryptographic primitives which are +//! today considered insecure. These should only be used for compatibility with +//! legacy systems, but never in new systems! When the `insecure` feature is +//! used, an `insecure` module is added to the crate root. All insecure +//! primitives are exposed through this module. + +#![doc(html_root_url = "https://docs.rs/mundane/0.2.0")] +#![deny(missing_docs)] +#![deny(warnings)] +#![feature(tool_lints)] +#![allow(stable_features)] +// just in case we forget to add #[forbid(unsafe_code)] on new module +// definitions +#![deny(unsafe_code)] + +#[macro_use] +mod macros; + +// Forbid unsafe code except in the boringssl module. +#[allow(unsafe_code)] +mod boringssl; +#[forbid(unsafe_code)] +pub mod hash; +#[forbid(unsafe_code)] +pub mod hmac; +#[cfg(feature = "insecure")] +#[forbid(unsafe_code)] +pub mod insecure; +#[cfg(feature = "kdf")] +#[forbid(unsafe_code)] +pub mod kdf; +#[forbid(unsafe_code)] +pub mod password; +#[forbid(unsafe_code)] +pub mod public; +#[forbid(unsafe_code)] +mod util; + +use std::fmt::{self, Debug, Display, Formatter}; + +use boringssl::BoringError; + +/// Reads cryptographically-secure random bytes. +/// +/// This is a low-level primitive often used to construct higher-level +/// protocols. Unless you're sure that this is what you need, you should +/// probably be using something else. For example, all key types can be randomly +/// generated using higher-level functions (e.g., [`EcPrivKey::generate`]), +/// scrypt nonces are generated using the [`scrypt_generate`] function, etc. +/// +/// [`EcPrivKey::generate`]: ::public::ec::EcPrivKey::generate +/// [`scrypt_generate`]: ::password::scrypt::scrypt_generate +#[cfg(feature = "rand-bytes")] +pub fn rand_bytes(bytes: &mut [u8]) { + boringssl::rand_bytes(bytes); +} + +/// Errors generated by this crate. +/// +/// `Error` represents two types of errors: errors generated by BoringSSL, and +/// errors generated by the Rust code in this crate. When printed (using either +/// `Display` or `Debug`), BoringSSL errors are of the form `boringssl: +/// <error>`, while errors generated by Rust code are of the form `<error>`. +pub struct Error(ErrorInner); + +impl Error { + fn new(s: String) -> Error { + Error(ErrorInner::Mundane(s)) + } +} + +#[doc(hidden)] +impl From<BoringError> for Error { + fn from(err: BoringError) -> Error { + Error(ErrorInner::Boring(err)) + } +} + +impl Display for Error { + fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> { + match &self.0 { + ErrorInner::Mundane(err) => write!(f, "{}", err), + ErrorInner::Boring(err) => write!(f, "boringssl: {}", err), + } + } +} + +impl Debug for Error { + fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> { + match &self.0 { + ErrorInner::Mundane(err) => write!(f, "{}", err), + + ErrorInner::Boring(err) => { + if err.stack_depth() == 1 { + // Either there was no stack trace, or the stack trace only + // contained a single frame. In either case, don't bother + // printing a preceding newline. + write!(f, "boringssl: {:?}", err) + } else { + // There's a multi-line stack trace, so print a preceding + // newline. + write!(f, "boringssl:\n{:?}", err) + } + } + } + } +} + +impl std::error::Error for Error {} + +enum ErrorInner { + Mundane(String), + Boring(BoringError), +} + +#[cfg(test)] +mod tests { + use super::Error; + + #[test] + fn test_send() { + fn assert_send<T: Send>() {} + assert_send::<Error>(); + } + + #[test] + fn test_sync() { + fn assert_sync<T: Sync>() {} + assert_sync::<Error>(); + } +}
diff --git a/src/macros.rs b/src/macros.rs new file mode 100644 index 0000000..4c98d13 --- /dev/null +++ b/src/macros.rs
@@ -0,0 +1,15 @@ +// Copyright 2018 Google LLC +// +// Use of this source code is governed by an MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT. + +macro_rules! impl_debug { + ($type:ty, $str:expr) => { + impl ::std::fmt::Debug for $type { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> Result<(), ::std::fmt::Error> { + write!(f, $str) + } + } + }; +}
diff --git a/src/password.rs b/src/password.rs new file mode 100644 index 0000000..e89f0eb --- /dev/null +++ b/src/password.rs
@@ -0,0 +1,253 @@ +// Copyright 2018 Google LLC +// +// Use of this source code is governed by an MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT. + +//! Password verification. + +/// The scrypt password hashing function. +/// +/// scrypt was originally proposed in [Stronger Key Derivation via Sequential +/// Memory-Hard Functions] and standardized in [RFC 7914]. +/// +/// A note on terminology: scrypt is technically a key derivation function, and +/// its output is thus technically a key. However, we expose it here only for +/// the purposes of password verification, and thus we use the term "hash" to +/// refer to its output. +/// +/// [Stronger Key Derivation via Sequential Memory-Hard Functions]: https://www.tarsnap.com/scrypt/scrypt.pdf +/// [RFC 7914]: https://tools.ietf.org/html/rfc7914 +pub mod scrypt { + use boringssl; + + // NOTE(joshlf): These are both set to 32 bytes (256 bits). This is probably + // overkill (128 bits is probably fine, as the lack of entropy in password + // hashes usually comes primarily from the passwords themselves), but better + // safe than sorry. Note that this is consistent with the Go scrypt + // documentation examples (https://godoc.org/golang.org/x/crypto/scrypt), + // while Go's bcrypt implementation + // (https://godoc.org/golang.org/x/crypto/bcrypt) uses a 128-bit salt and a + // 192-bit hash. + + /// The length of an scrypt hash. + /// + /// The value of this constant - 32 - is considered part of this API. Any + /// changes to it will be considered breaking changes. + pub const SCRYPT_HASH_LEN: usize = 32; + /// The length of an scrypt salt. + /// + /// The value of this constant - 32 - is considered part of this API. Any + /// changes to it will be considered breaking changes. + pub const SCRYPT_SALT_LEN: usize = 32; + + /// Recommended parameters for a production server. + /// + /// `SCRYPT_PARAMS_SERVER` is an appropriate set of parameters for running + /// scrypt on a production server in 2018. It targets 100ms of execution + /// time per generation or verification. + /// + /// The value of this constant may be updated periodically in order to keep + /// up with hardware trends. + pub const SCRYPT_PARAMS_SERVER: ScryptParams = ScryptParams { + // NOTE(joshlf): These were taken from the Go scrypt implementation + // (https://godoc.org/golang.org/x/crypto/scrypt) on 08/14/2018. + N: 32768, + r: 8, + p: 1, + }; + + /// Recommended paramaters for a laptop. + /// + /// `SCRYPT_PARAMS_LAPTOP` is an appropriate set of parameters for running + /// scrypt on a medium-range laptop in 2018. It targets 100ms of execution + /// time per generation or verification. + /// + /// The value of this constant may be updated periodically in order to keep + /// up with hardware trends. + pub const SCRYPT_PARAMS_LAPTOP: ScryptParams = ScryptParams { + // NOTE(joshlf): These were benchmarked on my laptop (2017 MacBook Pro + // 13-inch with a 3.5 GHz Intel Core i7 - model identifier + // MacBookPro14,2) on 08/14/2018. + N: 16384, + r: 8, + p: 1, + }; + + /// The parameters to the scrypt function. + /// + /// These parameters determine how much effort will be required in order to + /// generate or verify an scrypt hash. "Effort" here refers to utilization + /// of of CPU, memory, and memory bandwidth. For more details on what these + /// parameters mean and their implications, see [The scrypt Parameters]. For + /// sane defaults, see the `SCRYPT_PARAMS_XXX` constants. + /// + /// [The scrypt Parameters]: https://blog.filippo.io/the-scrypt-parameters/ + #[allow(non_snake_case)] + #[allow(missing_docs)] + #[derive(Debug, Copy, Clone)] + pub struct ScryptParams { + // NOTE(joshlf): These are private so that the user is forced to use one + // of our presets. If this turns out to be too brittle, it might be + // worth considering making these public, and simply discouraging + // (perhaps via a deprecation attribute) setting them directly. + N: u64, + r: u64, + p: u64, + } + + impl ScryptParams { + /// Gets the parameter N. + #[allow(non_snake_case)] + #[must_use] + pub fn N(&self) -> u64 { + self.N + } + + /// Gets the parameter r. + #[must_use] + pub fn r(&self) -> u64 { + self.r + } + + /// Gets the parameter p. + #[must_use] + pub fn p(&self) -> u64 { + self.p + } + } + + // Don't put a limit on the memory used by scrypt; it's too prone to + // failure. Instead, rely on choosing sane defaults for N, r, and p to + // ensure that we don't use too much memory. + const SCRYPT_MAX_MEM: usize = usize::max_value(); + + // TODO(joshlf): Provide a custom Debug impl for ScryptHash? + + /// The output of the scrypt password hashing function. + #[must_use] + #[allow(non_snake_case)] + #[derive(Debug, Copy, Clone)] + pub struct ScryptHash { + hash: [u8; SCRYPT_HASH_LEN], + salt: [u8; SCRYPT_SALT_LEN], + params: ScryptParams, + } + + impl ScryptHash { + // NOTE(joshlf): Normally, having three different parameters in a row of + // the same type would be dangerous because it's too easy to + // accidentally pass arguments in the wrong order. In this particular + // case, it's less of a concern because ScryptHash is only passed to the + // scrypt_verify function, so the worst that reordering these parameters + // can due is cause a valid hash to be mistakenly rejected as invalid. + // If this were a constructor on ScryptParams, which is passed as an + // argument to scrypt_generate, then a mistake might lead to + // accidentally generating a hash with weak security parameters, which + // would be a problem. + + /// Constructs a new `ScryptHash`. + #[allow(non_snake_case)] + #[must_use] + pub fn new( + hash: [u8; SCRYPT_HASH_LEN], salt: [u8; SCRYPT_SALT_LEN], N: u64, r: u64, p: u64, + ) -> ScryptHash { + ScryptHash { + hash, + salt, + params: ScryptParams { N, r, p }, + } + } + + /// Gets the hash. + #[must_use] + pub fn hash(&self) -> &[u8; SCRYPT_HASH_LEN] { + &self.hash + } + + /// Gets the salt. + #[must_use] + pub fn salt(&self) -> &[u8; SCRYPT_SALT_LEN] { + &self.salt + } + + /// Gets the params. + #[must_use] + pub fn params(&self) -> ScryptParams { + self.params + } + } + + /// Generates an scrypt hash for the given password. + /// + /// `scrypt_generate` uses scrypt to generate a hash for the given + /// `password` using the provided `params`. + #[must_use] + pub fn scrypt_generate(password: &[u8], params: &ScryptParams) -> ScryptHash { + let mut salt = [0u8; SCRYPT_SALT_LEN]; + boringssl::rand_bytes(&mut salt); + let mut hash = [0u8; SCRYPT_HASH_LEN]; + // Can only fail on OOM, max_mem exceeded (SCRYPT_MAX_MEM is max usize, + // so that definitely won't happen), or if any of the parameters are + // invalid (which would be a bug on our part). Thus, we unwrap. + boringssl::evp_pbe_scrypt( + password, + &salt, + params.N, + params.r, + params.p, + SCRYPT_MAX_MEM, + &mut hash, + ).unwrap(); + ScryptHash { + hash, + salt, + params: *params, + } + } + + /// Verifies a password against an scrypt hash. + /// + /// `scrypt_verify` verifies that `password` is the same password that was + /// used to generate `hash` using scrypt. + #[must_use] + pub fn scrypt_verify(password: &[u8], hash: &ScryptHash) -> bool { + let mut out_hash = [0u8; SCRYPT_HASH_LEN]; + if boringssl::evp_pbe_scrypt( + password, + &hash.salt, + hash.params.N, + hash.params.r, + hash.params.p, + SCRYPT_MAX_MEM, + &mut out_hash, + ).is_err() + { + return false; + } + boringssl::crypto_memcmp(&out_hash, &hash.hash) + } + + #[cfg(test)] + mod tests { + use super::*; + + #[test] + fn test_scrypt() { + for _ in 0..16 { + let mut pass = [0; 128]; + boringssl::rand_bytes(&mut pass); + // target 1 second of execution for this test on a laptop + let mut params = SCRYPT_PARAMS_LAPTOP; + params.N /= 4; + let hash = scrypt_generate(&pass, ¶ms); + assert!( + scrypt_verify(&pass, &hash), + "pass: {:?}, hash: {:?}", + &pass[..], + hash + ); + } + } + } +}
diff --git a/src/public/ec/curve.rs b/src/public/ec/curve.rs new file mode 100644 index 0000000..f7e0da7 --- /dev/null +++ b/src/public/ec/curve.rs
@@ -0,0 +1,144 @@ +// Copyright 2018 Google LLC +// +// Use of this source code is governed by an MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT. + +use std::borrow::Cow; +use std::fmt::{self, Debug, Display, Formatter}; +use std::os::raw::c_int; + +use boringssl::{self, BoringError}; +use util::Sealed; +use Error; + +/// The meat of the `Curve` trait. +/// +/// We put the meat of the trait - an inner `Curve` trait which actually has +/// methods on it - in a separate, private module because we don't want these +/// methods to be visible to users. +mod inner { + use Error; + + use boringssl::{self, CRef}; + use util::Sealed; + + /// An elliptic curve. + /// + /// `PCurve` is implemented by `P256`, `P384`, `P521`. + pub trait PCurve: Sized + Sealed { + /// Returns this curve's NID. + /// + /// Callers are allowed to assume that this NID is a valid one, and are + /// allowed to panic if it is not. + fn nid() -> i32; + + /// Returns the group named by `Self::nid()`. + fn group() -> CRef<'static, boringssl::EC_GROUP> { + CRef::ec_group_new_by_curve_name(Self::nid()).unwrap() + } + + /// Validate that an `EC_GROUP` is matches this group. + /// + /// If `group` is not equal to the curve's group, `from_group` returns + /// an error. + fn validate_group(group: CRef<boringssl::EC_GROUP>) -> Result<(), Error>; + } +} + +/// A NIST P elliptic curve. +/// +/// `PCurve` is implemented by [`P256`], [`P384`], and [`P521`]. The P-224 curve +/// is considered insecure, and thus is not supported. +/// +/// The P curves are defined by NIST and are used in the ECDSA and ECDH +/// algorithms. +/// +/// [`P256`]: ::public::ec::P256 +/// [`P384`]: ::public::ec::P384 +/// [`P521`]: ::public::ec::P521 +pub trait PCurve: Sized + Copy + Clone + Default + Display + Debug + self::inner::PCurve {} + +/// The P-256 curve. +#[derive(Copy, Clone, Default, Debug, Eq, PartialEq, Hash)] +pub struct P256; +/// The P-384 curve. +#[derive(Copy, Clone, Default, Debug, Eq, PartialEq, Hash)] +pub struct P384; +/// The P-521 curve. +#[derive(Copy, Clone, Default, Debug, Eq, PartialEq, Hash)] +pub struct P521; + +impl Display for P256 { + fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> { + write!(f, "P-256") + } +} +impl Display for P384 { + fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> { + write!(f, "P-384") + } +} +impl Display for P521 { + fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> { + write!(f, "P-521") + } +} + +const NID_P256: i32 = boringssl::NID_X9_62_prime256v1 as i32; +const NID_P384: i32 = boringssl::NID_secp384r1 as i32; +const NID_P521: i32 = boringssl::NID_secp521r1 as i32; + +macro_rules! impl_curve { + ($name:ident, $str:expr, $nid:ident) => { + impl self::inner::PCurve for $name { + fn nid() -> i32 { + $nid + } + fn validate_group(group: boringssl::CRef<boringssl::EC_GROUP>) -> Result<(), ::Error> { + let nid = group.ec_group_get_curve_name(); + if nid != $nid { + return Err(::Error::new(format!( + concat!("unexpected curve: got {}; want ", $str), + nid_name(nid).unwrap(), + ))); + } + Ok(()) + } + } + + impl Sealed for $name {} + impl PCurve for $name {} + }; +} + +impl_curve!(P256, "P-256", NID_P256); +impl_curve!(P384, "P-384", NID_P384); +impl_curve!(P521, "P-521", NID_P521); + +/// A dynamic representation of a curve. +pub enum CurveKind { + P256, + P384, + P521, +} + +impl CurveKind { + /// Get the `CurveKind` associated with a NID. + pub fn from_nid(nid: i32) -> Result<CurveKind, Error> { + match nid { + self::NID_P256 => Ok(CurveKind::P256), + self::NID_P384 => Ok(CurveKind::P384), + self::NID_P521 => Ok(CurveKind::P521), + _ => Err(Error::new(format!( + "unsupported curve: {}", + nid_name(nid).unwrap() + ))), + } + } +} + +// NOTE: Can only return an error due to an unknown NID +fn nid_name(nid: c_int) -> Result<Cow<'static, str>, BoringError> { + Ok(boringssl::ec_curve_nid2nist(nid)?.to_string_lossy()) +}
diff --git a/src/public/ec/mod.rs b/src/public/ec/mod.rs new file mode 100644 index 0000000..93a725a --- /dev/null +++ b/src/public/ec/mod.rs
@@ -0,0 +1,726 @@ +// Copyright 2018 Google LLC +// +// Use of this source code is governed by an MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT. + +//! Elliptic Curve-based cryptographic algorithms over NIST P curves. +//! +//! This module only supports elliptic curve cryptography over NIST's P curves, +//! defined in FIPS 186-3. These are the P-256, P-384, and P-521 curves (P-224 +//! is considered insecure, and thus is not supported). The ECDSA and ECDH +//! algorithms are both defined over P curves, and so are exposed in this +//! module. +//! +//! Other elliptic curve algorithms on non-P curves live in other modules (e.g., +//! operations on the Edwards 25519 curve live in the [`ed25519`] module). +//! +//! [`ed25519`]: ::public::ed25519 + +mod curve; + +pub use public::ec::curve::{PCurve, P256, P384, P521}; + +use std::fmt::{self, Debug, Formatter}; + +use boringssl::{CHeapWrapper, CStackWrapper}; +use public::ec::curve::CurveKind; +use public::ec::inner::EcKey; +use public::{inner::DerKey, DerPrivateKey, DerPublicKey, PrivateKey, PublicKey}; +use util::Sealed; +use Error; + +mod inner { + use std::marker::PhantomData; + + use boringssl::{self, BoringError, CHeapWrapper, CStackWrapper}; + use public::ec::curve::PCurve; + use public::inner::BoringDerKey; + use Error; + + // A convenience wrapper around boringssl::EC_KEY. + // + // EcKey maintains the following invariants: + // - The key is valid. + // - The key is on the curve C. + // + // This is marked pub and put in this (non-public) module so that using it in impls of + // the Key trait don't result in public-in-private errors. + #[derive(Clone)] + pub struct EcKey<C: PCurve> { + pub key: CHeapWrapper<boringssl::EC_KEY>, + _marker: PhantomData<C>, + } + + impl<C: PCurve> EcKey<C> { + pub fn generate() -> Result<EcKey<C>, BoringError> { + let mut key = CHeapWrapper::default(); + // EC_KEY_set_group only errors if there's already a group set + key.ec_key_set_group(&C::group()).unwrap(); + key.ec_key_generate_key()?; + Ok(EcKey { + key, + _marker: PhantomData, + }) + } + + /// Creates an `EcKey` from a BoringSSL `EC_KEY`. + /// + /// `from_EC_KEY` validates that `key`'s curve is `C`. + /// + /// # Panics + /// + /// `from_EC_KEY` panics if `key`'s group is not set. + #[allow(non_snake_case)] + pub fn from_EC_KEY(key: CHeapWrapper<boringssl::EC_KEY>) -> Result<EcKey<C>, Error> { + // ec_key_get0_group returns the EC_KEY's internal group pointer, + // which is guaranteed to be set by the caller. + C::validate_group(key.ec_key_get0_group().unwrap())?; + Ok(EcKey { + key, + _marker: PhantomData, + }) + } + } + + impl<C: PCurve> BoringDerKey for EcKey<C> { + fn pkey_assign(&self, pkey: &mut CHeapWrapper<boringssl::EVP_PKEY>) { + pkey.evp_pkey_assign_ec_key(self.key.clone()) + } + + // NOTE: panics if the key is an EC key and doesn't have a group set + // (due to EcKey::from_EC_KEY) + fn pkey_get(pkey: &mut CHeapWrapper<boringssl::EVP_PKEY>) -> Result<Self, Error> { + let key = pkey.evp_pkey_get1_ec_key()?; + EcKey::from_EC_KEY(key) + } + + fn parse_private_key(cbs: &mut CStackWrapper<boringssl::CBS>) -> Result<EcKey<C>, Error> { + // The last argument is a group. If it's not None, then it is either + // used as the group or, if the DER encoding also contains a group, + // the encoded group is validated against the group passed as an + // argument. Note that this validation is mostly redundant - similar + // validation is performed in EcKey::from_EC_KEY - however, it's not + // fully redundant, since it allows keys to be parsed which have no + // group. + let key = CHeapWrapper::ec_key_parse_private_key(cbs, Some(C::group()))?; + EcKey::from_EC_KEY(key) + } + + fn marshal_private_key( + &self, cbb: &mut CStackWrapper<boringssl::CBB>, + ) -> Result<(), Error> { + self.key.ec_key_marshal_private_key(cbb).map_err(From::from) + } + } + + #[cfg(test)] + mod tests { + use std::mem; + + use super::*; + use public::ec::{P256, P384, P521}; + + #[test] + fn test_refcount() { + fn test<C: PCurve>() { + let key = EcKey::<C>::generate().unwrap(); + for i in 0..8 { + // make i clones and then free them all + let mut keys = Vec::new(); + for _ in 0..i { + keys.push(key.clone()); + } + mem::drop(keys); + } + mem::drop(key); + } + + test::<P256>(); + test::<P384>(); + test::<P521>(); + } + } +} + +/// An elliptic curve public key over a P curve. +/// +/// `EcPubKey` is a public key over the curve `C`. +pub struct EcPubKey<C: PCurve> { + inner: EcKey<C>, +} + +impl<C: PCurve> Sealed for EcPubKey<C> {} +impl<C: PCurve> DerPublicKey for EcPubKey<C> {} + +impl<C: PCurve> DerKey for EcPubKey<C> { + type Boring = EcKey<C>; + fn boring(&self) -> &EcKey<C> { + &self.inner + } + fn from_boring(inner: EcKey<C>) -> EcPubKey<C> { + EcPubKey { inner } + } +} + +impl<C: PCurve> PublicKey for EcPubKey<C> { + type Private = EcPrivKey<C>; +} + +impl<C: PCurve> Debug for EcPubKey<C> { + fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> { + write!(f, "EcPubKey") + } +} + +/// An elliptic curve private key over a P curve. +/// +/// `EcPrivKey` is a private key over the curve `C`. +pub struct EcPrivKey<C: PCurve> { + inner: EcKey<C>, +} + +impl<C: PCurve> EcPrivKey<C> { + /// Generates a new private key. + #[must_use] + pub fn generate() -> Result<EcPrivKey<C>, Error> { + Ok(EcPrivKey { + inner: EcKey::generate()?, + }) + } +} + +impl<C: PCurve> Sealed for EcPrivKey<C> {} +impl<C: PCurve> DerPrivateKey for EcPrivKey<C> {} + +impl<C: PCurve> DerKey for EcPrivKey<C> { + type Boring = EcKey<C>; + fn boring(&self) -> &EcKey<C> { + &self.inner + } + fn from_boring(inner: EcKey<C>) -> EcPrivKey<C> { + EcPrivKey { inner } + } +} + +impl<C: PCurve> PrivateKey for EcPrivKey<C> { + type Public = EcPubKey<C>; + + fn public(&self) -> EcPubKey<C> { + EcPubKey { + inner: self.inner.clone(), + } + } +} + +impl<C: PCurve> Debug for EcPrivKey<C> { + fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> { + write!(f, "EcPrivKey") + } +} + +/// An elliptic curve public key whose curve is unknown at compile time. +/// +/// An `EcPubKeyAnyCurve` is an enum of [`EcPubKey`]s over the three supported +/// curves. It is returned from [`parse_public_key_der_any_curve`]. +#[allow(missing_docs)] +#[derive(Debug)] +pub enum EcPubKeyAnyCurve { + P256(EcPubKey<P256>), + P384(EcPubKey<P384>), + P521(EcPubKey<P521>), +} + +/// An elliptic curve private key whose curve is unknown at compile time. +/// +/// An `EcPrivKeyAnyCurve` is an enum of [`EcPrivKey`]s over the three supported +/// curves. It is returned from [`parse_private_key_der_any_curve`]. +#[allow(missing_docs)] +#[derive(Debug)] +pub enum EcPrivKeyAnyCurve { + P256(EcPrivKey<P256>), + P384(EcPrivKey<P384>), + P521(EcPrivKey<P521>), +} + +impl EcPrivKeyAnyCurve { + /// Gets the public key corresponding to this private key. + #[must_use] + pub fn public(&self) -> EcPubKeyAnyCurve { + match self { + EcPrivKeyAnyCurve::P256(key) => EcPubKeyAnyCurve::P256(key.public()), + EcPrivKeyAnyCurve::P384(key) => EcPubKeyAnyCurve::P384(key.public()), + EcPrivKeyAnyCurve::P521(key) => EcPubKeyAnyCurve::P521(key.public()), + } + } +} + +/// Parses a public key in DER format with any curve. +/// +/// `parse_public_key_der_any_curve` is like [`parse_public_key_der`], but it +/// accepts any [`PCurve`] rather than a particular, static curve. +/// +/// Since `parse_public_key_der` takes a [`PublicKey`] type argument, and +/// [`EcPubKey`] requires a static [`PCurve`] type parameter, +/// `parse_public_key_der` can only be called when the curve is known ahead of +/// time. `parse_public_key_der_any_curve`, on the other hand, accepts any +/// curve. It returns an [`EcPubKeyAnyCurve`], which is an enum of keys over the +/// three supported curves. +/// +/// Because the curve is not known statically, one must be specified in the DER +/// input. +/// +/// [`parse_public_key_der`]: ::public::parse_public_key_der +/// [`PublicKey`]: ::public::PublicKey +#[must_use] +pub fn parse_public_key_der_any_curve(bytes: &[u8]) -> Result<EcPubKeyAnyCurve, Error> { + CStackWrapper::cbs_with_temp_buffer(bytes, |cbs| { + let mut evp_pkey = CHeapWrapper::evp_parse_public_key(cbs)?; + let key = evp_pkey.evp_pkey_get1_ec_key()?; + if cbs.cbs_len() > 0 { + return Err(Error::new("malformed DER input".to_string())); + } + + // EVP_parse_public_key guarantees that the returned key has its group + // set, so this unwrap is safe. + let group = key.ec_key_get0_group().unwrap(); + Ok( + match CurveKind::from_nid(group.ec_group_get_curve_name())? { + CurveKind::P256 => EcPubKeyAnyCurve::P256(EcPubKey { + inner: EcKey::from_EC_KEY(key.clone())?, + }), + CurveKind::P384 => EcPubKeyAnyCurve::P384(EcPubKey { + inner: EcKey::from_EC_KEY(key.clone())?, + }), + CurveKind::P521 => EcPubKeyAnyCurve::P521(EcPubKey { + inner: EcKey::from_EC_KEY(key.clone())?, + }), + }, + ) + }) +} + +/// Parses a private key in DER format with any curve. +/// +/// `parse_private_key_der_any_curve` is like [`parse_private_key_der`], but it +/// accepts any [`PCurve`] rather than a particular, static curve. +/// +/// Since `parse_private_key_der` takes a [`PrivateKey`] type argument, and +/// [`EcPrivKey`] requires a static [`PCurve`] type parameter, +/// `parse_private_key_der` can only be called when the curve is known ahead of +/// time. `parse_private_key_der_any_curve`, on the other hand, accepts any +/// curve. It returns an [`EcPrivKeyAnyCurve`], which is an enum of keys over +/// the three supported curves. +/// +/// Because the curve is not known statically, one must be specified in the DER +/// input. +/// +/// [`parse_private_key_der`]: ::public::parse_private_key_der +/// [`PrivateKey`]: ::public::PrivateKey +#[must_use] +pub fn parse_private_key_der_any_curve(bytes: &[u8]) -> Result<EcPrivKeyAnyCurve, Error> { + CStackWrapper::cbs_with_temp_buffer(bytes, |cbs| { + // The last argument is a group. Since it's None, + // EC_KEY_parse_private_key will require the DER to name the group. + let key = CHeapWrapper::ec_key_parse_private_key(cbs, None)?; + if cbs.cbs_len() > 0 { + return Err(Error::new("malformed DER input".to_string())); + } + + // TODO(joshlf): Add documentation to EC_KEY_parse_private_key + // guaranteeing that the internal group pointer is set. + let group = key.ec_key_get0_group().unwrap(); + Ok( + match CurveKind::from_nid(group.ec_group_get_curve_name())? { + CurveKind::P256 => EcPrivKeyAnyCurve::P256(EcPrivKey { + inner: EcKey::from_EC_KEY(key.clone())?, + }), + CurveKind::P384 => EcPrivKeyAnyCurve::P384(EcPrivKey { + inner: EcKey::from_EC_KEY(key.clone())?, + }), + CurveKind::P521 => EcPrivKeyAnyCurve::P521(EcPrivKey { + inner: EcKey::from_EC_KEY(key.clone())?, + }), + }, + ) + }) +} + +/// The Elliptic Curve Digital Signature Algorithm. +pub mod ecdsa { + use std::fmt::{self, Debug, Formatter}; + use std::marker::PhantomData; + + use boringssl; + use hash::{inner::Digest, Hasher, Sha256, Sha384}; + use public::{ec::{EcPrivKey, EcPubKey, PCurve, P256, P384, P521}, + Signature}; + use util::Sealed; + use Error; + + /// A hash function which is compatible with ECDSA signatures over the curve + /// `C`. + /// + /// An ECDSA signature is constructed by hashing the message and then + /// signing the resulting digest. However, EC keys over certain curves may + /// not be compatible with all hashes. In particular, some digests may be + /// too long (in number of bytes) and thus not correspond to a point on the + /// curve. `EcdsaHash<C>` is implemented by all hash functions whose digests + /// are compatible with ECDSA signatures over the curve `C`. + pub trait EcdsaHash<C: PCurve>: Sealed {} + + impl EcdsaHash<P256> for Sha256 {} + impl EcdsaHash<P384> for Sha256 {} + impl EcdsaHash<P384> for Sha384 {} + impl EcdsaHash<P521> for Sha256 {} + impl EcdsaHash<P521> for Sha384 {} + + // The maximum length of an ECDSA signature over P-521. Since this isn't + // exposed in the API, we can increase later if we add support for curves + // with larger signatures. + // + // This was calculated with the following equation, which is thanks to + // agl@google.com: + // + // r = s = (521 + 7)/8 # Bytes to store the integers r and s + // = 66 + // DER encoded bytes = (1 # type byte 0x02 + // + 1 # length byte + // + 1 # possible 0 padding + // + 66) * 2 # one for each of r and s + // + 1 # ASN.1 SEQUENCE type byte + // + 2 # outer length + // = 141 + const MAX_SIGNATURE_LEN: usize = 141; + + /// A DER-encoded ECDSA signature. + #[must_use] + pub struct EcdsaSignature<C: PCurve, H: Hasher + EcdsaHash<C>> { + bytes: [u8; MAX_SIGNATURE_LEN], + // Invariant: len is in [0; MAX_SIGNATURE_LEN). If len is 0, it + // indicates an invalid signature. Invalid signatures can be produced + // when a caller invokes from_bytes with a byte slice longer than + // MAX_SIGNATURE_LEN. Such signatures cannot possibly have been + // generated by an ECDSA signature over any of the curves we support, + // and so it could not possibly be valid. In other words, it would never + // be correct for ecdsa_verify to return true when invoked on such a + // signature. + // + // However, if we were to simply truncate the byte slice and store a + // subset of it, then we might open ourselves up to attacks in which an + // attacker induces a mismatch between the signature that the caller + // /thinks/ is being verified and the signature that is /actually/ being + // verified. Thus, it's important that we always reject such signatures. + // + // Finally, it's OK for us to use 0 as the sentinal value to mean + // "invalid signature" because ECDSA can never produce a 0-byte + // signature. Thus, we will never produce a 0-byte signature from + // ecdsa_sign, and similarly, if the caller constructs a 0-byte + // signature using from_bytes, it's correct for us to treat it as + // invalid. + len: usize, + _marker: PhantomData<(C, H)>, + } + + impl<C: PCurve, H: Hasher + EcdsaHash<C>> EcdsaSignature<C, H> { + /// Constructs an `EcdsaSignature` from raw bytes. + #[must_use] + pub fn from_bytes(bytes: &[u8]) -> EcdsaSignature<C, H> { + if bytes.len() > MAX_SIGNATURE_LEN { + // see comment on the len field for why we do this + return Self::empty(); + } + let mut ret = Self::empty(); + (&mut ret.bytes[..bytes.len()]).copy_from_slice(bytes); + ret.len = bytes.len(); + ret + } + + // TODO(joshlf): Once we have const generics, have this return a + // fixed-length array. + + /// Gets the raw bytes of this `EcdsaSignature`. + #[must_use] + pub fn bytes(&self) -> &[u8] { + &self.bytes[..self.len] + } + + fn is_valid(&self) -> bool { + self.len != 0 + } + + fn empty() -> EcdsaSignature<C, H> { + EcdsaSignature { + bytes: [0u8; MAX_SIGNATURE_LEN], + len: 0, + _marker: PhantomData, + } + } + } + + impl<C: PCurve, H: Hasher + EcdsaHash<C>> Sealed for EcdsaSignature<C, H> {} + impl<C: PCurve, H: Hasher + EcdsaHash<C>> Signature for EcdsaSignature<C, H> { + type PrivateKey = EcPrivKey<C>; + + fn sign(key: &EcPrivKey<C>, message: &[u8]) -> Result<EcdsaSignature<C, H>, Error> { + let digest = H::hash(message); + let mut sig = EcdsaSignature::empty(); + sig.len = boringssl::ecdsa_sign(digest.as_ref(), &mut sig.bytes[..], &key.inner.key)?; + Ok(sig) + } + + fn verify(&self, key: &EcPubKey<C>, message: &[u8]) -> bool { + if !self.is_valid() { + // see comment on EcdsaSignature::len for why we do this + return false; + } + let digest = H::hash(message); + boringssl::ecdsa_verify(digest.as_ref(), self.bytes(), &key.inner.key) + } + } + + impl<C: PCurve, H: Hasher + EcdsaHash<C>> Debug for EcdsaSignature<C, H> { + fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> { + write!(f, "EcdsaSignature") + } + } + + #[cfg(test)] + mod tests { + use super::{super::*, *}; + use public::testutil::test_signature_smoke; + + #[test] + fn test_smoke() { + let p256 = EcPrivKey::<P256>::generate().unwrap(); + let p384 = EcPrivKey::<P384>::generate().unwrap(); + let p521 = EcPrivKey::<P521>::generate().unwrap(); + + test_signature_smoke( + &p256, + EcdsaSignature::<_, Sha256>::from_bytes, + EcdsaSignature::bytes, + ); + test_signature_smoke( + &p384, + EcdsaSignature::<_, Sha256>::from_bytes, + EcdsaSignature::bytes, + ); + test_signature_smoke( + &p384, + EcdsaSignature::<_, Sha384>::from_bytes, + EcdsaSignature::bytes, + ); + test_signature_smoke( + &p521, + EcdsaSignature::<_, Sha256>::from_bytes, + EcdsaSignature::bytes, + ); + test_signature_smoke( + &p521, + EcdsaSignature::<_, Sha384>::from_bytes, + EcdsaSignature::bytes, + ); + } + + #[test] + fn test_invalid_signature() { + fn test_is_invalid(sig: &EcdsaSignature<P256, Sha256>) { + assert_eq!(sig.len, 0); + assert!(!sig.is_valid()); + assert!(!sig.verify(&EcPrivKey::<P256>::generate().unwrap().public(), &[],)); + } + test_is_invalid(&EcdsaSignature::from_bytes(&[0; MAX_SIGNATURE_LEN + 1])); + test_is_invalid(&EcdsaSignature::from_bytes(&[])); + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + use hash::Sha256; + use public::ec::ecdsa::*; + use public::{marshal_private_key_der, marshal_public_key_der, parse_private_key_der, + parse_public_key_der, Signature}; + use util::should_fail; + + #[test] + fn test_generate() { + EcPrivKey::<P256>::generate().unwrap(); + EcPrivKey::<P384>::generate().unwrap(); + EcPrivKey::<P521>::generate().unwrap(); + } + + #[test] + fn test_marshal_parse() { + // Test various combinations of parsing and serializing keys. + // + // Since we need to test dynamic parsing (the + // parse_private_key_der_any_curve and parse_public_key_der_any_curve + // functions), we need a way of unwrapping their return values into a + // static key type. Unfortunately, there's no way (on stable Rust) to do + // that generically, so the caller must pass a function which will do + // it. + fn test< + C: PCurve, + F: Fn(EcPrivKeyAnyCurve) -> EcPrivKey<C>, + G: Fn(EcPubKeyAnyCurve) -> EcPubKey<C>, + >( + unwrap_priv_any: F, unwrap_pub_any: G, + ) where + Sha256: EcdsaHash<C>, + { + const MESSAGE: &[u8] = &[0, 1, 2, 3, 4, 5, 6, 7]; + let key = EcPrivKey::<C>::generate().unwrap(); + + let parsed_key: EcPrivKey<C> = + parse_private_key_der(&marshal_private_key_der(&key)).unwrap(); + let parsed_key_any_curve = unwrap_priv_any( + parse_private_key_der_any_curve(&marshal_private_key_der(&key)).unwrap(), + ); + let pubkey = key.public(); + let parsed_pubkey: EcPubKey<C> = + parse_public_key_der(&marshal_public_key_der(&pubkey)).unwrap(); + let parsed_pubkey_any_curve = unwrap_pub_any( + parse_public_key_der_any_curve(&marshal_public_key_der(&pubkey)).unwrap(), + ); + + fn sign_and_verify<C1: PCurve, C2: PCurve>( + privkey: &EcPrivKey<C1>, pubkey: &EcPubKey<C2>, + ) where + Sha256: EcdsaHash<C1>, + Sha256: EcdsaHash<C2>, + { + let sig = EcdsaSignature::<C1, Sha256>::sign(&privkey, MESSAGE).unwrap(); + assert!( + EcdsaSignature::<C2, Sha256>::from_bytes(sig.bytes()).verify(&pubkey, MESSAGE) + ) + } + + // Sign and verify with every pair of keys to make sure we parsed + // the same key we marshaled. + sign_and_verify(&key, &pubkey); + sign_and_verify(&key, &parsed_pubkey); + sign_and_verify(&key, &parsed_pubkey_any_curve); + sign_and_verify(&parsed_key, &pubkey); + sign_and_verify(&parsed_key, &parsed_pubkey); + sign_and_verify(&parsed_key, &parsed_pubkey_any_curve); + sign_and_verify(&parsed_key_any_curve, &pubkey); + sign_and_verify(&parsed_key_any_curve, &parsed_pubkey); + sign_and_verify(&parsed_key_any_curve, &parsed_pubkey_any_curve); + + let _ = marshal_public_key_der::<EcPubKey<C>>; + let _ = parse_public_key_der::<EcPubKey<C>>; + } + + macro_rules! unwrap_any_curve { + ($name:ident, $any_type:ty, $key_type:ty, $curve_variant:path) => { + fn $name(key: $any_type) -> $key_type { + match key { + $curve_variant(key) => key, + _ => panic!("unexpected curve"), + } + } + }; + } + + unwrap_any_curve!( + unwrap_priv_key_any_p256, + EcPrivKeyAnyCurve, + EcPrivKey<P256>, + EcPrivKeyAnyCurve::P256 + ); + unwrap_any_curve!( + unwrap_priv_key_any_p384, + EcPrivKeyAnyCurve, + EcPrivKey<P384>, + EcPrivKeyAnyCurve::P384 + ); + unwrap_any_curve!( + unwrap_priv_key_any_p521, + EcPrivKeyAnyCurve, + EcPrivKey<P521>, + EcPrivKeyAnyCurve::P521 + ); + unwrap_any_curve!( + unwrap_pub_key_any_p256, + EcPubKeyAnyCurve, + EcPubKey<P256>, + EcPubKeyAnyCurve::P256 + ); + unwrap_any_curve!( + unwrap_pub_key_any_p384, + EcPubKeyAnyCurve, + EcPubKey<P384>, + EcPubKeyAnyCurve::P384 + ); + unwrap_any_curve!( + unwrap_pub_key_any_p521, + EcPubKeyAnyCurve, + EcPubKey<P521>, + EcPubKeyAnyCurve::P521 + ); + + test::<P256, _, _>(unwrap_priv_key_any_p256, unwrap_pub_key_any_p256); + test::<P384, _, _>(unwrap_priv_key_any_p384, unwrap_pub_key_any_p384); + test::<P521, _, _>(unwrap_priv_key_any_p521, unwrap_pub_key_any_p521); + } + + #[test] + fn test_parse_fail() { + // Test that invalid input is rejected. + fn test_parse_invalid<C: PCurve>() { + should_fail( + parse_private_key_der::<EcPrivKey<C>>(&[]), + "parse_private_key_der", + "elliptic curve routines:OPENSSL_internal:DECODE_ERROR", + ); + should_fail( + parse_public_key_der::<EcPubKey<C>>(&[]), + "parse_public_key_der", + "public key routines:OPENSSL_internal:DECODE_ERROR", + ); + should_fail( + parse_private_key_der_any_curve(&[]), + "parse_private_key_der_any_curve", + "elliptic curve routines:OPENSSL_internal:DECODE_ERROR", + ); + should_fail( + parse_public_key_der_any_curve(&[]), + "parse_public_key_der_any_curve", + "public key routines:OPENSSL_internal:DECODE_ERROR", + ); + } + + test_parse_invalid::<P256>(); + test_parse_invalid::<P384>(); + test_parse_invalid::<P521>(); + + // Test that, when a particular curve is expected, other curves are + // rejected. + fn test_parse_wrong_curve<C1: PCurve, C2: PCurve>() { + let privkey = EcPrivKey::<C1>::generate().unwrap(); + let key_der = marshal_private_key_der(&privkey); + should_fail( + parse_private_key_der::<EcPrivKey<C2>>(&key_der), + "parse_private_key_der", + "elliptic curve routines:OPENSSL_internal:GROUP_MISMATCH", + ); + let key_der = marshal_public_key_der(&privkey.public()); + should_fail( + parse_public_key_der::<EcPubKey<C2>>(&key_der), + "parse_public_key_der", + "mundane: unexpected curve:", + ); + } + + // All pairs of curves, (X, Y), such that X != Y. + test_parse_wrong_curve::<P256, P384>(); + test_parse_wrong_curve::<P256, P521>(); + test_parse_wrong_curve::<P384, P256>(); + test_parse_wrong_curve::<P384, P521>(); + test_parse_wrong_curve::<P521, P256>(); + test_parse_wrong_curve::<P521, P384>(); + } +}
diff --git a/src/public/ed25519.rs b/src/public/ed25519.rs new file mode 100644 index 0000000..21bf3ea --- /dev/null +++ b/src/public/ed25519.rs
@@ -0,0 +1,212 @@ +// Copyright 2018 Google LLC +// +// Use of this source code is governed by an MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT. + +//! The Ed25519 signature algorithm. + +use boringssl::{ed25519_keypair, ed25519_keypair_from_seed, ed25519_sign, ed25519_verify}; +use public::{PrivateKey, PublicKey, Signature}; +use util::Sealed; +use Error; + +const ED25519_PUBLIC_KEY_LEN: usize = ::boringssl::ED25519_PUBLIC_KEY_LEN as usize; +const ED25519_PRIVATE_KEY_LEN: usize = ::boringssl::ED25519_PRIVATE_KEY_LEN as usize; +const ED25519_SIGNATURE_LEN: usize = ::boringssl::ED25519_SIGNATURE_LEN as usize; +// BoringSSL stores both a private and a public key in their private key +// representation. The private key comes first, followed by the public key. +const ED25519_PUBLIC_KEY_OFFSET: usize = ED25519_PRIVATE_KEY_LEN - ED25519_PUBLIC_KEY_LEN; + +/// An Ed25519 public key. +pub struct Ed25519PubKey { + key: [u8; ED25519_PUBLIC_KEY_LEN], +} + +impl Ed25519PubKey { + /// Constructs a new public key from bytes. + #[must_use] + pub fn from_bytes(bytes: [u8; ED25519_PUBLIC_KEY_LEN]) -> Ed25519PubKey { + Ed25519PubKey { key: bytes } + } + + /// Gets the raw bytes of the public key. + #[must_use] + pub fn bytes(&self) -> &[u8; ED25519_PUBLIC_KEY_LEN] { + &self.key + } +} + +impl_debug!(Ed25519PubKey, "Ed25519PubKey"); + +impl Sealed for Ed25519PubKey {} +impl PublicKey for Ed25519PubKey { + type Private = Ed25519PrivKey; +} + +/// An Ed25519 private key. +/// +/// An `Ed25519PrivKey` actually includes both the private key and the public +/// key in order to make multiple key signing operations with the same key more +/// efficient. +pub struct Ed25519PrivKey { + key: [u8; ED25519_PRIVATE_KEY_LEN], +} + +impl_debug!(Ed25519PrivKey, "Ed25519PrivKey"); + +impl Ed25519PrivKey { + /// Generates a new private key. + #[must_use] + pub fn generate() -> Ed25519PrivKey { + Ed25519PrivKey { + key: ed25519_keypair(), + } + } + + /// Constructs a new private key from a key pair. + /// + /// Usually, an Ed25519 private key will be stored as a single 64-byte blob: + /// the 32-byte private key followed by the 32-byte public key. However, we + /// accept the two keys as separate arguments in case they are stored + /// separately. + #[must_use] + pub fn from_key_pair_bytes(private: [u8; 32], public: &Ed25519PubKey) -> Ed25519PrivKey { + let mut key = [0u8; ED25519_PRIVATE_KEY_LEN]; + (&mut key[..32]).copy_from_slice(&private); + (&mut key[ED25519_PUBLIC_KEY_OFFSET..]).copy_from_slice(&public.key); + Ed25519PrivKey { key } + } + + /// Constructs a new private key. + /// + /// Unlike [`from_key_pair_bytes`], `from_private_key_bytes` reconstructs + /// the key (which includes both the private key and the public key + /// internally) from only the private key. + /// + /// [`from_key_pair_bytes`]: ::public::ed25519::Ed25519PrivKey::from_key_pair_bytes + #[must_use] + pub fn from_private_key_bytes(private: [u8; 32]) -> Ed25519PrivKey { + let (_, key) = ed25519_keypair_from_seed(&private); + Ed25519PrivKey { key } + } + + /// Gets the raw bytes of the private key. + #[must_use] + pub fn bytes(&self) -> &[u8; ED25519_PRIVATE_KEY_LEN] { + &self.key + } +} + +impl Sealed for Ed25519PrivKey {} +impl PrivateKey for Ed25519PrivKey { + type Public = Ed25519PubKey; + + fn public(&self) -> Ed25519PubKey { + let mut public = [0u8; ED25519_PUBLIC_KEY_LEN]; + (&mut public[..]).copy_from_slice(&self.key[ED25519_PUBLIC_KEY_OFFSET..]); + Ed25519PubKey { key: public } + } +} + +/// An Ed25519 signature. +#[must_use] +pub struct Ed25519Signature { + sig: [u8; ED25519_SIGNATURE_LEN], +} + +impl_debug!(Ed25519Signature, "Ed25519Signature"); + +impl Ed25519Signature { + /// Constructs an `Ed25519Signature` signature from raw bytes. + #[must_use] + pub fn from_bytes(bytes: [u8; ED25519_SIGNATURE_LEN]) -> Ed25519Signature { + Ed25519Signature { sig: bytes } + } + + /// Gets the raw bytes of the signature. + #[must_use] + pub fn bytes(&self) -> &[u8; ED25519_SIGNATURE_LEN] { + &self.sig + } + + /// Sign a message. + /// + /// `Ed25519Signature` implements [`Signature`], but `Signature`'s [`sign`] + /// function conservatively returns a `Result`. Ed25519 signatures never + /// fail, so this function is provided to allow the user to compute an + /// Ed25519 signature without having to perform error checking. + /// + /// [`Signature`]: ::public::Signature + /// [`sign`]: ::public::Signature::sign + #[must_use] + pub fn sign_ed25519(key: &Ed25519PrivKey, message: &[u8]) -> Ed25519Signature { + Ed25519Signature { + // ED25519_sign can only return an error on OOM + sig: ed25519_sign(message, &key.key).unwrap(), + } + } +} + +impl Sealed for Ed25519Signature {} +impl Signature for Ed25519Signature { + type PrivateKey = Ed25519PrivKey; + + /// Sign a message. + /// + /// Though the [`Signature`] trait requires that [`sign`] return a `Result`, + /// `Ed25519Signature`'s implementation is guaranteed to always return `Ok`. + /// Callers may prefer the [`sign_ed25519`] function, which returns an + /// `Ed25519Signature` rather than a `Result`. + /// + /// [`Signature`]: ::public::Signature + /// [`sign`]: ::public::Signature::sign + /// [`sign_ed25519`]: ::public::ed25519::Ed25519Signature::sign_ed25519 + fn sign(key: &Ed25519PrivKey, message: &[u8]) -> Result<Ed25519Signature, Error> { + Ok(Ed25519Signature::sign_ed25519(key, message)) + } + + fn verify(&self, key: &Ed25519PubKey, message: &[u8]) -> bool { + ed25519_verify(message, &self.sig, &key.key) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use public::testutil::test_signature_smoke; + + #[test] + fn test_priv_key_constructors() { + let key = Ed25519PrivKey::generate(); + let mut private = [0u8; 32]; + (&mut private[..]).copy_from_slice(&key.key[..32]); + let key2 = Ed25519PrivKey::from_private_key_bytes(private); + assert_eq!(&key.key[..], &key2.key[..]); + + let mut private = [0u8; 32]; + let mut public = [0u8; 32]; + let bytes = *key.bytes(); + (&mut private[..]).copy_from_slice(&bytes[..32]); + (&mut public[..]).copy_from_slice(&bytes[32..]); + let key2 = Ed25519PrivKey::from_key_pair_bytes(private, &Ed25519PubKey::from_bytes(public)); + assert_eq!(&key.key[..], &key2.key[..]); + } + + #[test] + fn test_smoke() { + let key = Ed25519PrivKey::generate(); + let from_bytes = |bytes: &[u8]| { + let mut sig = [0u8; ED25519_SIGNATURE_LEN]; + let len = ::std::cmp::min(sig.len(), bytes.len()); + (&mut sig[..len]).copy_from_slice(&bytes[..len]); + Ed25519Signature::from_bytes(sig) + }; + // for some reason, defining this as a closure results in type inference + // issues that aren't worth debugging + fn to_bytes(sig: &Ed25519Signature) -> &[u8] { + &sig.bytes()[..] + } + test_signature_smoke(&key, from_bytes, to_bytes); + } +}
diff --git a/src/public/mod.rs b/src/public/mod.rs new file mode 100644 index 0000000..26dc754 --- /dev/null +++ b/src/public/mod.rs
@@ -0,0 +1,226 @@ +// Copyright 2018 Google LLC +// +// Use of this source code is governed by an MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT. + +//! Public key cryptography. + +pub mod ec; +pub mod ed25519; + +use boringssl::{CHeapWrapper, CStackWrapper}; +use public::inner::BoringDerKey; +use util::Sealed; +use Error; + +/// The public component of a public/private key pair. +pub trait PublicKey: Sealed + Sized { + /// The type of the private component. + type Private: PrivateKey<Public = Self>; +} + +/// The private component of a public/private key pair. +pub trait PrivateKey: Sealed + Sized { + /// The type of the public component. + type Public: PublicKey<Private = Self>; + + /// Gets the public key corresponding to this private key. + #[must_use] + fn public(&self) -> Self::Public; +} + +/// A public key which can be encoded as a DER object. +pub trait DerPublicKey: PublicKey + self::inner::DerKey {} + +/// A private key which can be encoded as a DER object. +pub trait DerPrivateKey: PrivateKey + self::inner::DerKey {} + +/// A cryptographic signature generated by a private key. +pub trait Signature: Sealed + Sized { + /// The private key type used to generate this signature. + type PrivateKey: PrivateKey; + + /// Sign a message. + /// + /// The input to this function is always a message, never a digest. If a + /// signature scheme calls for hashing a message and signing the hash + /// digest, `sign` is responsible for both hashing and signing. + #[must_use] + fn sign(key: &Self::PrivateKey, message: &[u8]) -> Result<Self, Error>; + + /// Verify a signature. + /// + /// The input to this function is always a message, never a digest. If a + /// signature scheme calls for hashing a message and signing the hash + /// digest, `verify` is responsible for both hashing and verifying the + /// digest. + #[must_use] + fn verify(&self, key: &<Self::PrivateKey as PrivateKey>::Public, message: &[u8]) -> bool; +} + +mod inner { + use boringssl::{self, CHeapWrapper, CStackWrapper}; + use Error; + + /// A wrapper around a BoringSSL key object. + pub trait BoringDerKey: Sized { + // evp_pkey_assign_xxx + fn pkey_assign(&self, pkey: &mut CHeapWrapper<boringssl::EVP_PKEY>); + + // evp_pkey_get_xxx; panics if the key is an EC key and doesn't have a group set, + // and errors if pkey isn't the expected key type + fn pkey_get(pkey: &mut CHeapWrapper<boringssl::EVP_PKEY>) -> Result<Self, Error>; + + // xxx_parse_private_key + fn parse_private_key(cbs: &mut CStackWrapper<boringssl::CBS>) -> Result<Self, Error>; + + // xxx_marshal_private_key + fn marshal_private_key(&self, cbb: &mut CStackWrapper<boringssl::CBB>) + -> Result<(), Error>; + } + + /// Properties shared by both public and private keys of a given type. + pub trait DerKey { + /// The underlying BoringSSL object wrapper type. + type Boring: BoringDerKey; + + fn boring(&self) -> &Self::Boring; + + fn from_boring(Self::Boring) -> Self; + } +} + +/// Marshals a public key in DER format. +/// +/// `marshal_public_key_der` marshals a public key as a DER-encoded +/// SubjectPublicKeyInfo structure as defined in [RFC 5280]. +/// +/// [RFC 5280]: https://tools.ietf.org/html/rfc5280 +#[must_use] +pub fn marshal_public_key_der<P: DerPublicKey>(key: &P) -> Vec<u8> { + let mut evp_pkey = CHeapWrapper::default(); + key.boring().pkey_assign(&mut evp_pkey); + // cbb_new can only fail due to OOM + let mut cbb = CStackWrapper::cbb_new(64).unwrap(); + evp_pkey + .evp_marshal_public_key(&mut cbb) + .expect("failed to marshal public key"); + cbb.cbb_with_data(<[u8]>::to_vec) +} + +/// Marshals a private key in DER format. +/// +/// `marshal_private_key_der` marshal a private key as a DER-encoded structure. +/// The exact structure encoded depends on the type of key: +/// - For an EC key, it is an ECPrivateKey structure as defined in [RFC 5915]. +/// - For an RSA key, it is an RSAPrivateKey structure as defined in [RFC 3447]. +/// +/// [RFC 5915]: https://tools.ietf.org/html/rfc5915 +/// [RFC 3447]: https://tools.ietf.org/html/rfc3447 +#[must_use] +pub fn marshal_private_key_der<P: DerPrivateKey>(key: &P) -> Vec<u8> { + // cbb_new can only fail due to OOM + let mut cbb = CStackWrapper::cbb_new(64).unwrap(); + key.boring() + .marshal_private_key(&mut cbb) + .expect("failed to marshal private key"); + cbb.cbb_with_data(<[u8]>::to_vec) +} + +/// Parses a public key in DER format. +/// +/// `parse_public_key_der` parses a public key from a DER-encoded +/// SubjectPublicKeyInfo structure as defined in [RFC 5280]. +/// +/// # Elliptic Curve Keys +/// +/// For Elliptic Curve keys ([`EcPubKey`]), the curve itself is validated. If +/// the curve is not known ahead of time, and any curve must be supported at +/// runtime, use the [`parse_public_key_der_any_curve`] function. +/// +/// [RFC 5280]: https://tools.ietf.org/html/rfc5280 +/// [`EcPubKey`]: ::public::ec::EcPubKey +/// [`parse_public_key_der_any_curve`]: ::public::ec::parse_public_key_der_any_curve +#[must_use] +pub fn parse_public_key_der<P: DerPublicKey>(bytes: &[u8]) -> Result<P, Error> { + CStackWrapper::cbs_with_temp_buffer(bytes, |cbs| { + let mut evp_pkey = CHeapWrapper::evp_parse_public_key(cbs)?; + // NOTE: For EC, panics if evp_pkey doesn't have its group set. This is + // OK because EVP_parse_public_key guarantees that the returned key has + // its group set. + let key = P::Boring::pkey_get(&mut evp_pkey)?; + if cbs.cbs_len() > 0 { + return Err(Error::new("malformed DER input".to_string())); + } + Ok(P::from_boring(key)) + }) +} + +/// Parses a private key in DER format. +/// +/// `parse_private_key_der` parses a private key from a DER-encoded format. The +/// exact structure expected depends on the type of key: +/// - For an EC key, it is an ECPrivateKey structure as defined in [RFC 5915]. +/// - For an RSA key, it is an RSAPrivateKey structure as defined in [RFC 3447]. +/// +/// # Elliptic Curve Keys +/// +/// For Elliptic Curve keys ([`EcPrivKey`]), the curve itself is validated. If +/// the curve is not known ahead of time, and any curve must be supported at +/// runtime, use the [`parse_private_key_der_any_curve`] function. +/// +/// [RFC 5915]: https://tools.ietf.org/html/rfc5915 +/// [RFC 3447]: https://tools.ietf.org/html/rfc3447 +/// [`EcPrivKey`]: ::public::ec::EcPrivKey +/// [`parse_private_key_der_any_curve`]: ::public::ec::parse_private_key_der_any_curve +#[must_use] +pub fn parse_private_key_der<P: DerPrivateKey>(bytes: &[u8]) -> Result<P, Error> { + CStackWrapper::cbs_with_temp_buffer(bytes, |cbs| { + let key = P::Boring::parse_private_key(cbs)?; + if cbs.cbs_len() > 0 { + return Err(Error::new("malformed DER input".to_string())); + } + Ok(P::from_boring(key)) + }) +} + +#[cfg(test)] +mod testutil { + use super::*; + + /// Smoke test a signature scheme. + /// + /// `sig_from_bytes` takes a byte slice and converts it into a signature. If + /// the byte slice is too long, it either truncate it or treats it as + /// invalid (it's up to the caller). If the byte slice is too short, it + /// fills in the remaining bytes with zeroes. + pub fn test_signature_smoke<S: Signature, F: Fn(&[u8]) -> S, G: Fn(&S) -> &[u8]>( + key: &S::PrivateKey, sig_from_bytes: F, bytes_from_sig: G, + ) { + // Sign the message, verify the signature, and return the signature. + // Also verify that, if the wrong signature is used, the signature fails + // to verify. Also verify that sig_from_bytes works. + fn sign_and_verify<S: Signature, F: Fn(&[u8]) -> S, G: Fn(&S) -> &[u8]>( + key: &S::PrivateKey, message: &[u8], sig_from_bytes: F, bytes_from_sig: G, + ) -> S { + let sig = S::sign(key, message).unwrap(); + assert!(sig.verify(&key.public(), message)); + let sig2 = S::sign(&key, bytes_from_sig(&sig)).unwrap(); + assert!(!sig2.verify(&key.public(), message)); + sig_from_bytes(bytes_from_sig(&sig)) + } + + // Sign an empty message, and verify the signature. Use the signature as + // the next message to test, and repeat many times. + let mut msg = Vec::new(); + for _ in 0..16 { + msg = bytes_from_sig(&sign_and_verify( + key, + &msg, + &sig_from_bytes, + &bytes_from_sig, + )).to_vec(); + } + } +}
diff --git a/src/util.rs b/src/util.rs new file mode 100644 index 0000000..b9bb0e7 --- /dev/null +++ b/src/util.rs
@@ -0,0 +1,37 @@ +// Copyright 2018 Google LLC +// +// Use of this source code is governed by an MIT-style +// license that can be found in the LICENSE file or at +// https://opensource.org/licenses/MIT. + +/// A trait that can be used to ensure that users of this crate can't implement +/// a trait. +/// +/// See the [API Guidelines] for details. +/// +/// [API Guidelines]: https://rust-lang-nursery.github.io/api-guidelines/future-proofing.html#sealed-traits-protect-against-downstream-implementations-c-sealed +pub trait Sealed {} + +/// Expects that a `Result` is an error. +/// +/// `should_fail` ensures that `result` is an error, and that the error's +/// `Debug` representation contains the string `expected_substr`. Otherwise, it +/// panics. +#[cfg(test)] +pub fn should_fail<O, E: ::std::fmt::Debug>( + result: Result<O, E>, desc: &str, expected_substr: &str, +) { + // Credit to agl@google.com for this implementation. + match result { + Ok(_) => panic!("{} unexpectedly succeeded", desc), + Err(err) => { + let err_str = format!("{:?}", err); + err_str.find(expected_substr).unwrap_or_else(|| { + panic!( + "{} resulted in error that doesn't include {:?}: {:?}", + desc, expected_substr, err_str + ) + }); + } + } +}