diff --git a/.github/workflows/cargo_check.yml b/.github/workflows/cargo_check.yml index d74e600..d110619 100644 --- a/.github/workflows/cargo_check.yml +++ b/.github/workflows/cargo_check.yml @@ -94,9 +94,3 @@ jobs: with: command: check args: --target thumbv7em-none-eabi --release --examples - - - name: Check bootloader - uses: actions-rs/cargo@v1 - with: - command: check - args: --manifest-path bootloader/Cargo.toml --target thumbv7em-none-eabi --release diff --git a/Cargo.toml b/Cargo.toml index 91e2211..85765fd 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -24,12 +24,13 @@ embedded-time = "0.12.1" arbitrary = { version = "0.4.7", features = ["derive"], optional = true } rand = { version = "0.8.4", optional = true } ed25519-compact = { version = "1", default-features = false, optional = true } +dilithium = { path = "third_party/dilithium" } [features] debug_allocations = ["lang_items/debug_allocations"] debug_ctap = ["libtock_drivers/debug_ctap"] panic_console = ["lang_items/panic_console"] -std = ["crypto/std", "lang_items/std", "persistent_store/std", "rng256/std", "rand"] +std = ["crypto/std", "dilithium/std", "lang_items/std", "persistent_store/std", "rng256/std", "rand"] verbose = ["debug_ctap", "libtock_drivers/verbose_usb"] with_ctap1 = ["crypto/with_ctap1"] with_nfc = ["libtock_drivers/with_nfc"] diff --git a/README.md b/README.md index 7ea4886..bfd0a6e 100644 --- a/README.md +++ b/README.md @@ -1,84 +1,114 @@ # OpenSK logo -![markdownlint](https://github.com/google/OpenSK/workflows/markdownlint/badge.svg?branch=develop) -![pylint](https://github.com/google/OpenSK/workflows/pylint/badge.svg?branch=develop) -![Cargo check](https://github.com/google/OpenSK/workflows/Cargo%20check/badge.svg?branch=develop) -![Cargo format](https://github.com/google/OpenSK/workflows/Cargo%20format/badge.svg?branch=develop) -[![Coverage Status](https://coveralls.io/repos/github/google/OpenSK/badge.svg?branch=develop)](https://coveralls.io/github/google/OpenSK?branch=develop) - ## OpenSK -This repository contains a Rust implementation of a -[FIDO2](https://fidoalliance.org/fido2/) authenticator. -We developed OpenSK as a [Tock OS](https://tockos.org) application. +This is an OpenSK fork that allows signing with a PQC Hybrid scheme. If you are looking for the original documentation, please check the +[develop branch of its GitHub page](https://github.com/google/OpenSK/tree/develop). -We intend to bring a full open source experience to security keys, from -application to operating system. You can even 3D print your own open source -enclosure! -You can see OpenSK in action in this -[video on YouTube](https://www.youtube.com/watch?v=klEozvpw0xg)! - -You are viewing the branch for developers. New features are developed here -before they are stabilized. If you instead want to use the FIDO certified -firmware, please go back to the -[stable branch](https://github.com/google/OpenSK). - -### FIDO2 - -The develop branch implements the -[CTAP2.1 specification](https://fidoalliance.org/specs/fido-v2.1-ps-20210615/fido-client-to-authenticator-protocol-v2.1-ps-20210615.html). -This branch is not FIDO certified. The implementation is backwards compatible -to CTAP2.0. Additionally, OpenSK supports U2F, and non-discoverable credentials -created with either protocol are compatible with the other. - -### :warning: Disclaimer - -This project is **proof-of-concept and a research platform**. It is **NOT** -meant for a daily usage. It comes with a few limitations: - -* This branch is under development, and therefore less rigorously tested than the stable branch. -* The cryptography implementations are not resistent against side-channel attacks. - -We're still in the process of integrating the -[ARM® CryptoCell-310](https://developer.arm.com/ip-products/security-ip/cryptocell-300-family) -embedded in the -[Nordic nRF52840 chip](https://infocenter.nordicsemi.com/index.jsp?topic=%2Fps_nrf52840%2Fcryptocell.html) -to enable hardware-accelerated cryptography. Our placeholder implementations of required -cryptography algorithms (ECDSA, ECC secp256r1, HMAC-SHA256 and AES256) in Rust are research-quality -code. They haven't been reviewed and don't provide constant-time guarantees. - ## Hardware -You will need one the following supported boards: - -* [Nordic nRF52840-DK](https://www.nordicsemi.com/Software-and-Tools/Development-Kits/nRF52840-DK) - development kit. This board is more convenient for development and debug - scenarios as the JTAG probe is already on the board. -* [Nordic nRF52840 Dongle](https://www.nordicsemi.com/Software-and-tools/Development-Kits/nRF52840-Dongle) - to have a more practical form factor. -* [Makerdiary nRF52840-MDK USB dongle](https://wiki.makerdiary.com/nrf52840-mdk/). -* [Feitian OpenSK dongle](https://feitiantech.github.io/OpenSK_USB/). +You will need a +[Nordic nRF52840-DK](https://www.nordicsemi.com/Software-and-Tools/Development-Kits/nRF52840-DK) +development kit. ## Installation To install OpenSK, + 1. follow the [general setup steps](docs/install.md), 1. then continue with the instructions for your specific hardware: - * [Nordic nRF52840-DK](docs/boards/nrf52840dk.md) - * [Nordic nRF52840 Dongle](docs/boards/nrf52840_dongle.md) - * [Makerdiary nRF52840-MDK USB dongle](docs/boards/nrf52840_mdk.md) - * [Feitian OpenSK dongle](docs/boards/nrf52840_feitian.md) + [Nordic nRF52840-DK](docs/boards/nrf52840dk.md) -To test whether the installation was successful, visit a -[demo website](https://webauthn.io/) and try to register and login. -Please check our [Troubleshooting and Debugging](docs/debugging.md) section if you -have problems with the installation process or during development. To find out what -else you can do with your OpenSK, see [Customization](docs/customization.md). +## PQC Experiments -## Contributing +### Modes -See [Contributing.md](docs/contributing.md). +The Dilithium mode is set at compile time. If you want to perform experiments for different modes, +you will need to recompile. The mode is a feature, defined in +`third_party/dilithium/Cargo.toml`. By default, it is set to +`default = [ "dilithium5", "optimize_stack" ]`. You can change the default mode by either changing +the number 5 to 2 or 3. Or you remove the feature for stack optimizations, e.g. +`default = [ "dilithium2" ]`. -## Reporting a Vulnerability +Note that some benchmarks will not run in all modes without stack optimizations. You can try to +play with the stack size in these cases. As an example, stack painting for speed mode Dilithium2 +works if you apply the following changes: + +* `APP_HEAP_SIZE = 16384` in `deploy.py` +* `libtock_core::stack_size! {0x1A000}` in `examples/measure_stack.rs` +* `STACK_SIZE = 106496;` in `nrf52840_layout.ld` +* Change the app break from `70 * 1024` to `104 * 1024` in `patches/tock/07-app-break-fix.patch`. + +For your convenience, you can also simply try: + +``` +git apply increase_stack.patch +``` + +### Compiler flags + +To trade binary size for speed, you can play with `[profile.release]` in `Cargo.toml`. +For example, try a different compiler optimization level: + +``` +opt-level = 3 +``` + +### Debug output + +Only the CTAP commands tests are measured end to end on the host. All other experiments are +measured on the embedded device itself and output over RTT. You can either use a client to print +results by running the following commands in different terminals: + +``` +JLinkExe -device nrf52 -if swd -speed 1000 -autoconnect 1 +JLinkRTTClient +``` + +Or you directly output all messages to a file: + +``` +JLinkRTTLogger -device NRF52840_XXAA -if swd -speed 1000 -RTTchannel 0 +``` + +### Perform Experiments + +The paper contains the following experiments: + +#### Crypto benchmarks + +Deploy the `crypto_bench` example and read the debug output with one of the methods above: + +``` +./deploy.py --board=nrf52840dk_opensk --crypto_bench +``` + +#### CTAP benchmarks + +To measure the speed of FIDO commands, run: + +``` +python benchmarks.py --runs=2000 +``` + +Aggregate results will be printed, and the raw data is written to `make_durations.txt` and +`get_durations.txt`. + + +#### Stack painting + +Deploy the `measure_stack` example and read the debug output with one of the methods above: + +``` +./deploy.py --board=nrf52840dk_opensk --measure_stack +``` + +#### x86 benchmarks + +You don't need your embedded hardware for those, run: + +``` +cd third_party/dilithium/ +cargo bench --features std +``` -See [SECURITY.md](SECURITY.md). diff --git a/benchmarks.py b/benchmarks.py new file mode 100644 index 0000000..1f64ae6 --- /dev/null +++ b/benchmarks.py @@ -0,0 +1,167 @@ +#!/usr/bin/env python3 +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# Lint as: python3 +"""Script to benchmark CTAP commands using Dilithium Hybrid signatures.""" + +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +import argparse +import datetime +from subprocess import DEVNULL, STDOUT, check_call +import sys +from time import sleep +from typing import Any +import uuid + +import colorama +from tqdm.auto import tqdm + +from fido2 import ctap +from fido2.webauthn import PublicKeyCredentialRpEntity, PublicKeyCredentialUserEntity, PublicKeyCredentialParameters +from fido2 import hid +from tools.configure import fatal, info, get_opensk_devices + +ES256_ALGORITHM = PublicKeyCredentialParameters("public-key", -7) +HYBRID_ALGORITHM = PublicKeyCredentialParameters("public-key", -65537) + + +def error(message: str): + tqdm.write(message) + + +def check_info(authenticator: Any): + """Checks if the assumed upgrade info matches the authenticator's.""" + try: + info("Reading info...") + if HYBRID_ALGORITHM not in authenticator.info.algorithms: + fatal("The device does not support hybrid signatures.") + except ctap.CtapError as ex: + error(f"Failed to read OpenSK info (error: {ex}") + + +def f_args(*params): + """Constructs a dict from a list of arguments for sending a CBOR command. + None elements will be omitted. + :param params: Arguments, in order, to add to the command. + :return: The input parameters as a dict. + """ + return dict((i, v) for i, v in enumerate(params, 1) if v is not None) + + +def compute_stats(elapsed): + n = len(elapsed) + mean = sum(elapsed) / n + variance = sum((x - mean)**2 for x in elapsed) / n + std_dev = variance**0.5 + return (mean, std_dev) + + +def get_authenticator(): + devices = None + while not devices: + try: + devices = get_opensk_devices(False) + except Exception as e: # pylint: disable=broad-except + error(str(e)) + check_call(["nrfjprog", "--reset", "--family", "NRF52"], + stdout=DEVNULL, + stderr=STDOUT) + sleep(0.1) + return devices[0] + + +def main(args): + colorama.init() + + authenticator = get_authenticator() + # If the device supports it, wink to show which device we use. + if authenticator.device.capabilities & hid.CAPABILITY.WINK: + authenticator.device.wink() + aaguid = uuid.UUID(bytes=authenticator.get_info().aaguid) + check_info(authenticator) + info(f"Testing OpenSK device AAGUID {aaguid} ({authenticator.device}).") + + make_durations = [] + get_durations = [] + + for _ in tqdm(range(args.runs), file=sys.stdout): + authenticator = get_authenticator() + try: + start = datetime.datetime.now() + result = authenticator.make_credential( + client_data_hash=bytes(32), + rp=PublicKeyCredentialRpEntity(id="example.com", name="Example"), + user=PublicKeyCredentialUserEntity(id=b"diana", name="Diana"), + key_params=[HYBRID_ALGORITHM], + ) + end = datetime.datetime.now() + make_delta = (end - start).total_seconds() * 1000.0 + make_durations.append(make_delta) + + credential_data = result.auth_data.credential_data + credential_id_length = 256 * credential_data[16] + credential_data[17] + credential_id = credential_data[18:18 + credential_id_length] + allow_list = [{"type": "public-key", "id": credential_id}] + + start = datetime.datetime.now() + _ = authenticator.get_assertion( + rp_id="example.com", + client_data_hash=bytes(32), + allow_list=allow_list, + ) + end = datetime.datetime.now() + get_delta = (end - start).total_seconds() * 1000.0 + get_durations.append(get_delta) + + with open("make_durations.txt", "a", encoding="utf-8") as file_make: + file_make.write(str(make_delta) + ",\n") + with open("get_durations.txt", "a", encoding="utf-8") as file_get: + file_get.write(str(get_delta) + ",\n") + + except ctap.CtapError as ex: + message = "Failed to make a hybrid signature with OpenSK" + if ex.code.value == ctap.CtapError.ERR.INVALID_COMMAND: + error(f"{message} (unsupported command).") + elif ex.code.value == ctap.CtapError.ERR.INVALID_PARAMETER: + error(f"{message} (invalid parameter, maybe a wrong byte array size?).") + elif ex.code.value == 0xF2: # VENDOR_INTERNAL_ERROR + error(f"{message} (internal conditions not met).") + elif ex.code.value == 0xF3: # VENDOR_HARDWARE_FAILURE + error(f"{message} (internal hardware error).") + else: + error(f"{message} (unexpected error: {ex})") + except Exception as e: # pylint: disable=broad-except + error(str(e)) + + info(f"Successful operations: {len(make_durations)} and {len(get_durations)}") + info("\nMake Credential benchmark:") + (mean, std_dev) = compute_stats(make_durations) + info(f"Average: {mean} ms/iter (standard deviation: {std_dev} ms/iter)") + info("\nGet Assertion benchmark:") + (mean, std_dev) = compute_stats(get_durations) + info(f"Average: {mean} ms/iter (standard deviation: {std_dev} ms/iter)") + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument( + "--runs", + type=int, + default=1000, + help=("How many iterations to use."), + ) + main(parser.parse_args()) diff --git a/deploy.py b/deploy.py index df0529f..90476f8 100755 --- a/deploy.py +++ b/deploy.py @@ -156,9 +156,7 @@ SUPPORTED_BOARDS = { ), } -# The following value must match the one used in the file -# `src/entry_point.rs` -APP_HEAP_SIZE = 90000 +APP_HEAP_SIZE = 32768 def get_supported_boards() -> Tuple[str]: @@ -1177,6 +1175,12 @@ if __name__ == "__main__": const="crypto_bench", help=("Compiles and installs the crypto_bench example that benchmarks " "the performance of the cryptographic algorithms on the board.")) + apps_group.add_argument( + "--measure_stack", + dest="application", + action="store_const", + const="measure_stack", + help=("Measures stack usage of Dilithium.")) apps_group.add_argument( "--store_latency", dest="application", diff --git a/examples/crypto_bench.rs b/examples/crypto_bench.rs index 2a1bd65..b643104 100644 --- a/examples/crypto_bench.rs +++ b/examples/crypto_bench.rs @@ -17,27 +17,42 @@ extern crate alloc; extern crate lang_items; -use alloc::format; -use alloc::vec::Vec; use core::fmt::Write; -use crypto::{aes256, cbc, ecdsa, sha256, Hash256}; +use crypto::sha256::Sha256; +use crypto::{ecdsa, hybrid}; use libtock_drivers::console::Console; use libtock_drivers::result::FlexUnwrap; use libtock_drivers::timer; use libtock_drivers::timer::{Timer, Timestamp}; -use rng256::TockRng256; +use rng256::Rng256; +// use ctap2::env::tock::{take_storage, TockStorage}; +// use persistent_store::Store; -libtock_core::stack_size! {0x800} +libtock_core::stack_size! {0x11800} + +/*fn boot_store(mut storage: TockStorage, erase: bool) -> Store { + use persistent_store::Storage; + let num_pages = storage.num_pages(); + if erase { + for page in 0..num_pages { + storage.erase_page(page).unwrap(); + } + } + Store::new(storage).ok().unwrap() +}*/ fn main() { + // Fix to be faster. + //let storage = take_storage().unwrap(); + //let mut _store = boot_store(storage, true); + let mut console = Console::new(); + let mut rng = rng256::TockRng256 {}; // Setup the timer with a dummy callback (we only care about reading the current time, but the // API forces us to set an alarm callback too). let mut with_callback = timer::with_callback(|_, _| {}); let timer = with_callback.init().flex_unwrap(); - let mut rng = TockRng256 {}; - writeln!(console, "****************************************").unwrap(); writeln!( console, @@ -46,136 +61,133 @@ fn main() { ) .unwrap(); - // AES - bench(&mut console, &timer, "aes256::EncryptionKey::new", || { - aes256::EncryptionKey::new(&[0; 32]); - }); - let ek = aes256::EncryptionKey::new(&[0; 32]); - bench(&mut console, &timer, "aes256::DecryptionKey::new", || { - aes256::DecryptionKey::new(&ek); - }); - let dk = aes256::DecryptionKey::new(&ek); - - bench( + custom_bench( &mut console, &timer, - "aes256::EncryptionKey::encrypt_block", - || { - ek.encrypt_block(&mut [0; 16]); - }, - ); - bench( - &mut console, - &timer, - "aes256::DecryptionKey::decrypt_block", - || { - dk.decrypt_block(&mut [0; 16]); + "ECDSA keygen", + 1000, + || {}, + |()| { + let k = ecdsa::SecKey::gensk(&mut rng); + k.genpk(); }, ); - // CBC - let mut blocks = Vec::new(); - for i in 0..8 { - blocks.resize(1 << (i + 4), 0); - bench( - &mut console, - &timer, - &format!("cbc::cbc_encrypt({} bytes)", blocks.len()), - || { - cbc::cbc_encrypt(&ek, [0; 16], &mut blocks); - }, - ); - } - drop(blocks); - - let mut blocks = Vec::new(); - for i in 0..8 { - blocks.resize(1 << (i + 4), 0); - bench( - &mut console, - &timer, - &format!("cbc::cbc_decrypt({} bytes)", blocks.len()), - || { - cbc::cbc_decrypt(&dk, [0; 16], &mut blocks); - }, - ); - } - drop(blocks); - - // SHA-256 - let mut contents = Vec::new(); - for i in 0..8 { - contents.resize(16 << i, 0); - bench( - &mut console, - &timer, - &format!("sha256::Sha256::update({} bytes)", contents.len()), - || { - let mut sha = sha256::Sha256::new(); - sha.update(&contents); - sha.finalize(); - }, - ); - } - drop(contents); - - // ECDSA - bench(&mut console, &timer, "ecdsa::SecKey::gensk", || { - ecdsa::SecKey::gensk(&mut rng); - }); - let k = ecdsa::SecKey::gensk(&mut rng); - bench(&mut console, &timer, "ecdsa::SecKey::genpk", || { - k.genpk(); - }); - bench( + custom_bench( &mut console, &timer, - "ecdsa::SecKey::sign_rng::", + "ECDSA sign", + 1000, || { - k.sign_rng::(&[], &mut rng); + let k = ecdsa::SecKey::gensk(&mut rng); + let mut m = [0; 64]; + rng.fill_bytes(&mut m); + (k, m) }, - ); - bench( - &mut console, - &timer, - "ecdsa::SecKey::sign_rfc6979::", - || { - k.sign_rfc6979::(&[]); + |(k, m)| { + k.sign_rfc6979::(&m); }, ); - writeln!(console, "****************************************").unwrap(); - writeln!(console, "All the benchmarks are done.\nHave a nice day!").unwrap(); - writeln!(console, "****************************************").unwrap(); + custom_bench( + &mut console, + &timer, + "dilithium::SecKey::gensk_with_pk", + 1000, + || {}, + |()| { + dilithium::sign::SecKey::gensk_with_pk(&mut rng); + }, + ); + + custom_bench( + &mut console, + &timer, + "dilithium::SecKey::sign", + 1000, + || { + let sk = dilithium::sign::SecKey::gensk(&mut rng); + let mut m = [0; 64]; + rng.fill_bytes(&mut m); + (sk, m) + }, + |(sk, m)| { + sk.sign(&m); + }, + ); + + custom_bench( + &mut console, + &timer, + "hybrid::SecKey::gensk_with_pk", + 1000, + || {}, + |()| { + hybrid::SecKey::gensk_with_pk(&mut rng); + }, + ); + + custom_bench( + &mut console, + &timer, + "hybrid::SecKey::sign", + 1000, + || { + let sk = hybrid::SecKey::gensk(&mut rng); + let mut m = [0; 64]; + rng.fill_bytes(&mut m); + (sk, m) + }, + |(sk, m)| { + sk.sign_rfc6979::(&m).to_asn1_der(); + }, + ); } -fn bench(console: &mut Console, timer: &Timer, title: &str, mut f: F) -where - F: FnMut(), +fn custom_bench( + console: &mut Console, + timer: &Timer, + title: &str, + iter_count: usize, + mut setup: S, + mut f: F, +) where + S: FnMut() -> I, + F: FnMut(I) -> O, { writeln!(console, "****************************************").unwrap(); writeln!(console, "Benchmarking: {}", title).unwrap(); writeln!(console, "----------------------------------------").unwrap(); - let mut count = 1; - for _ in 0..30 { + + let mut elapsed = 0.0; + + for _ in 1..(iter_count + 1) { + let inputs = setup(); let start = Timestamp::::from_clock_value(timer.get_current_clock().flex_unwrap()); - for _ in 0..count { - f(); - } + f(inputs); let end = Timestamp::::from_clock_value(timer.get_current_clock().flex_unwrap()); - let elapsed = (end - start).ms(); - writeln!( - console, - "{} ms elapsed for {} iterations ({} ms/iter)", - elapsed, - count, - elapsed / (count as f64) - ) - .unwrap(); - console.flush(); - if elapsed > 1000.0 { - break; + + let mut run_duration = (end - start).ms(); + + // After 512 seconds, we get a negative difference between the start + // time and the end time. + if run_duration < 0.0 { + run_duration += 512.0 * 1000.0; } - count <<= 1; + + elapsed += run_duration; + + writeln!(console, "{},", run_duration).unwrap(); + console.flush(); } + + writeln!( + console, + "Total: {} ms elapsed for {} iterations ({} ms/iter)", + elapsed, + iter_count, + elapsed / (iter_count as f64) + ) + .unwrap(); + console.flush(); } diff --git a/examples/measure_stack.rs b/examples/measure_stack.rs new file mode 100644 index 0000000..6acec14 --- /dev/null +++ b/examples/measure_stack.rs @@ -0,0 +1,184 @@ +// Copyright 2022 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#![no_std] +#![feature(asm)] +#![feature(llvm_asm)] +#![allow(dead_code)] + +extern crate alloc; +extern crate lang_items; + +use core::fmt::Write; +use core::ptr; +use crypto::sha256::Sha256; +use crypto::{ecdsa, hybrid, sha256}; +use libtock_drivers::console::Console; + +libtock_core::stack_size! {0x11800} + +#[inline(never)] +fn read_stack_pointer() -> u32 { + let x = 1u32; + let address = &x as *const u32; + address as u32 +} + +#[inline(never)] +fn print_stack_pointer(console: &mut Console) { + let x = 1u32; + writeln!(console, "Stack pointer: {:?}", &x as *const u32).unwrap(); +} + +/// Writes a byte pattern to a memory range. +/// +/// Since the stack grows to lower addresses, end < start. +/// Addresses after start must be unused, i.e. start must be at least the current stack pointer. +/// Addresses until end should be within the stack area. +unsafe fn paint_memory(start: u32, end: u32) { + for address in (end..start).step_by(4) { + let p = address as *const u32; + ptr::write(p as *mut u32, 0xCDCDCDCD); + } +} + +/// Find the lowest address that does not have the 0xCD pattern. +unsafe fn find_border(start: u32, end: u32) -> u32 { + for address in (end..start).step_by(4) { + let p = address as *const u32; + if ptr::read(p) != 0xCDCDCDCD { + return address; + } + } + start +} + +#[inline(never)] +pub fn black_box(dummy: T) -> T { + unsafe { llvm_asm!("" : : "r"(&dummy)) } + dummy +} + +#[inline(never)] +fn keygen_ecdsa(rng: &mut rng256::TockRng256) { + let sk = ecdsa::SecKey::gensk(rng); + black_box(sk); +} + +#[inline(never)] +fn keygen_dilithium(rng: &mut rng256::TockRng256) { + let sk = dilithium::sign::SecKey::gensk(rng); + black_box(sk); +} + +#[inline(never)] +fn keygen_hybrid(rng: &mut rng256::TockRng256) { + let sk = hybrid::SecKey::gensk_with_pk(rng); + black_box(sk); +} + +#[inline(never)] +fn sign_ecdsa(rng: &mut rng256::TockRng256, sk: &ecdsa::SecKey) { + let sig = sk.sign_rng::(&[], rng); + black_box(sig); +} + +fn sign_dilithium(sk: &dilithium::sign::SecKey) { + let sig = sk.sign(&[]); + black_box(sig); +} + +#[inline(never)] +fn sign_hybrid(sk: &hybrid::SecKey) { + let sig = sk.sign_rfc6979::(&[]); + black_box(sig); +} + +// Measure the stack usage of the method itself, plus a u32. +#[inline(never)] +fn dummy_test() { + let x = 1u32; + black_box(x); +} + +// Tests whether input parameters are correctly ignored in the measurement. +#[inline(never)] +fn param_test(big_param: &mut [u8; 0x1000]) { + let x = 0x01; + big_param[0] = x; + black_box(x); +} + +fn write_result(console: &mut Console, text: &str, size: u32) { + writeln!(console, "{} size: 0x{:08X}", text, size).unwrap(); +} + +fn main() { + let mut console = Console::new(); + + let x = 1u32; + let sp = &x as *const u32; + // Should be safe to write from here. + let start = sp as u32 - 0x100u32; + writeln!(console, "Search start address: 0x{:08X}", start).unwrap(); + print_stack_pointer(&mut console); + + let mut rng = rng256::TockRng256 {}; + + unsafe { paint_memory(start, 0x20020000) }; + keygen_ecdsa(&mut rng); + let min_address1 = unsafe { find_border(start, 0x20020000) }; + + unsafe { paint_memory(start, 0x20020000) }; + keygen_dilithium(&mut rng); + let min_address2 = unsafe { find_border(start, 0x20020000) }; + + unsafe { paint_memory(start, 0x20020000) }; + keygen_hybrid(&mut rng); + let min_address3 = unsafe { find_border(start, 0x20020000) }; + + let sk = ecdsa::SecKey::gensk(&mut rng); + unsafe { paint_memory(start, 0x20020000) }; + sign_ecdsa(&mut rng, &sk); + let min_address4 = unsafe { find_border(start, 0x20020000) }; + + let sk = dilithium::sign::SecKey::gensk(&mut rng); + unsafe { paint_memory(start, 0x20020000) }; + sign_dilithium(&sk); + let min_address5 = unsafe { find_border(start, 0x20020000) }; + + let sk = hybrid::SecKey::gensk(&mut rng); + unsafe { paint_memory(start, 0x20020000) }; + sign_hybrid(&sk); + let min_address6 = unsafe { find_border(start, 0x20020000) }; + + let mut param = [0; 0x1000]; + unsafe { paint_memory(start, 0x20020000) }; + param_test(&mut param); + let min_address7 = unsafe { find_border(start, 0x20020000) }; + + unsafe { paint_memory(start, 0x20020000) }; + dummy_test(); + let min_address8 = unsafe { find_border(start, 0x20020000) }; + + let main_end = read_stack_pointer(); + write_result(&mut console, " keygen_ecdsa", main_end - min_address1); + write_result(&mut console, "keygen_dilithium", main_end - min_address2); + write_result(&mut console, " keygen_hybrid", main_end - min_address3); + write_result(&mut console, " sign_ecdsa", main_end - min_address4); + write_result(&mut console, " sign_dilithium", main_end - min_address5); + write_result(&mut console, " sign_hybrid", main_end - min_address6); + write_result(&mut console, " test dummy", main_end - min_address7); + write_result(&mut console, " test input", main_end - min_address8); +} diff --git a/examples/nfct_test.rs b/examples/nfct_test.rs index 3483a92..0add1d0 100644 --- a/examples/nfct_test.rs +++ b/examples/nfct_test.rs @@ -132,49 +132,49 @@ mod example { match buf[0] { 0xe0 /* RATS */=> { let mut answer_to_select = [0x05, 0x78, 0x80, 0xB1, 0x00]; - return_code = bench_transmit(&mut console, &timer, "TX: ATS", &mut answer_to_select); + return_code = bench_transmit(&mut console, timer, "TX: ATS", &mut answer_to_select); } 0xc2 /* DESELECT */ => { // Ignore the request let mut command_error = [0x6A, 0x81]; - return_code = bench_transmit(&mut console, &timer, "TX: DESELECT", &mut command_error); + return_code = bench_transmit(&mut console, timer, "TX: DESELECT", &mut command_error); } 0x02 | 0x03 /* APDU Prefix */ => match buf[2] { // If the received packet is applet selection command (FIDO 2) 0xa4 /* SELECT */ => if buf[3] == 0x04 && buf[5] == 0x08 && buf[6] == 0xa0 { // Vesion: "FIDO_2_0" let mut reply = [buf[0], 0x46, 0x49, 0x44, 0x4f, 0x5f, 0x32, 0x5f, 0x30, 0x90, 0x00,]; - return_code = bench_transmit(&mut console, &timer, "TX: Version Str", &mut reply); + return_code = bench_transmit(&mut console, timer, "TX: Version Str", &mut reply); } else if (buf[6] == 0xd2 && buf[7] == 0x76) || (buf[6] == 0xe1 && (buf[7] == 0x03 || buf[7] == 0x04)){ let mut reply = [buf[0], 0x90, 0x00]; - return_code = bench_transmit(&mut console, &timer, "TX: 0x9000", &mut reply); + return_code = bench_transmit(&mut console, timer, "TX: 0x9000", &mut reply); } else /* Unknown file */ { let mut reply = [buf[0], 0x6a, 0x82]; - return_code = bench_transmit(&mut console, &timer, "TX: 0x6A82", &mut reply); + return_code = bench_transmit(&mut console, timer, "TX: 0x6A82", &mut reply); } 0xb0 /* READ */ => match buf[5] { 0x02 => { let mut reply = [buf[0], 0x12, 0x90, 0x00,]; - return_code = bench_transmit(&mut console, &timer, "TX: File Size", &mut reply); + return_code = bench_transmit(&mut console, timer, "TX: File Size", &mut reply); } 0x12 => { let mut reply = [buf[0], 0xd1, 0x01, 0x0e, 0x55, 0x77, 0x77, 0x77, 0x2e, 0x6f, 0x70, 0x65, 0x6e, 0x73, 0x6b, 0x2e, 0x64, 0x65, 0x76, 0x90, 0x00,]; - return_code = bench_transmit(&mut console, &timer, "TX: NDEF", &mut reply); + return_code = bench_transmit(&mut console, timer, "TX: NDEF", &mut reply); } 0x0f => { let mut reply = [buf[0], 0x00, 0x0f, 0x20, 0x00, 0x7f, 0x00, 0x7f, 0x04, 0x06, 0xe1, 0x04, 0x00, 0x7f, 0x00, 0x00, 0x90, 0x00,]; - return_code = bench_transmit(&mut console, &timer, "TX: CC", &mut reply); + return_code = bench_transmit(&mut console, timer, "TX: CC", &mut reply); } _ => { let mut reply = [buf[0], 0x90, 0x00]; - return_code = bench_transmit(&mut console, &timer, "TX: 0x9000", &mut reply); + return_code = bench_transmit(&mut console, timer, "TX: 0x9000", &mut reply); } } _ => { let mut reply = [buf[0], 0x90, 0x00]; - return_code = bench_transmit(&mut console, &timer, "TX: 0x9000", &mut reply); + return_code = bench_transmit(&mut console, timer, "TX: 0x9000", &mut reply); } } 0x26 | 0x52 | 0x50 /* REQA | WUPA | Halt */ => { diff --git a/increase_stack.patch b/increase_stack.patch new file mode 100644 index 0000000..77c0b24 --- /dev/null +++ b/increase_stack.patch @@ -0,0 +1,52 @@ +diff --git a/deploy.py b/deploy.py +index 7f91a2b..f7b1e9a 100755 +--- a/deploy.py ++++ b/deploy.py +@@ -156,7 +156,7 @@ SUPPORTED_BOARDS = { + ), + } + +-APP_HEAP_SIZE = 32768 ++APP_HEAP_SIZE = 16384 + + + def get_supported_boards() -> Tuple[str]: +diff --git a/examples/measure_stack.rs b/examples/measure_stack.rs +index 88f9ebc..d285a80 100644 +--- a/examples/measure_stack.rs ++++ b/examples/measure_stack.rs +@@ -26,7 +26,7 @@ use crypto::{ecdsa, hybrid, sha256}; + use crypto::sha256::Sha256; + use libtock_drivers::console::Console; + +-libtock_core::stack_size! {0x11800} ++libtock_core::stack_size! {0x1A000} + + #[inline(never)] + fn read_stack_pointer() -> u32 { +diff --git a/nrf52840_layout.ld b/nrf52840_layout.ld +index 538a2a8..c7dd5e7 100644 +--- a/nrf52840_layout.ld ++++ b/nrf52840_layout.ld +@@ -14,7 +14,7 @@ MEMORY { + * Any change to STACK_SIZE should be accompanied by a corresponding change to + * `elf2tab`'s `--stack` option + */ +-STACK_SIZE = 71680; ++STACK_SIZE = 106496; + + MPU_MIN_ALIGN = 8K; + +diff --git a/patches/tock/07-app-break-fix.patch b/patches/tock/07-app-break-fix.patch +index fcf46fd..4048b59 100644 +--- a/patches/tock/07-app-break-fix.patch ++++ b/patches/tock/07-app-break-fix.patch +@@ -7,7 +7,7 @@ index c78b1c9fb..2769d0138 100644 + // The 1.x Tock kernel allocates at least 3 kB to processes, and we need + // to ensure that happens as userspace may expect it. + - 3 * 1024 +-+ 70 * 1024 +++ 104 * 1024 + + // TOCK 2.0 + // diff --git a/libraries/crypto/Cargo.toml b/libraries/crypto/Cargo.toml index 12944d0..6c4b6d1 100644 --- a/libraries/crypto/Cargo.toml +++ b/libraries/crypto/Cargo.toml @@ -13,6 +13,7 @@ edition = "2018" rng256 = { path = "../rng256" } arrayref = "0.3.6" subtle = { version = "2.2.3", default-features = false, features = ["nightly"] } +dilithium = { path = "../../third_party/dilithium" } byteorder = { version = "1", default-features = false } hex = { version = "0.3.2", default-features = false, optional = true } ring = { version = "0.16.11", optional = true } diff --git a/libraries/crypto/src/ec/exponent256.rs b/libraries/crypto/src/ec/exponent256.rs index 8f4a87d..6eba531 100644 --- a/libraries/crypto/src/ec/exponent256.rs +++ b/libraries/crypto/src/ec/exponent256.rs @@ -308,6 +308,11 @@ pub mod test { } impl Rng256 for StressTestingRng { + // This function is unused, as we redefine gen_uniform_u32x8. + fn fill_bytes(&mut self, _buf: &mut [u8]) { + unreachable!() + } + // This function is unused, as we redefine gen_uniform_u32x8. fn gen_uniform_u8x32(&mut self) -> [u8; 32] { unreachable!() diff --git a/libraries/crypto/src/ec/point.rs b/libraries/crypto/src/ec/point.rs index bc55057..0f87200 100644 --- a/libraries/crypto/src/ec/point.rs +++ b/libraries/crypto/src/ec/point.rs @@ -25,7 +25,7 @@ use subtle::{Choice, ConditionallySelectable, ConstantTimeEq}; // A point on the elliptic curve is represented by two field elements. // The "direct" representation with GFP256 (integer modulo p) is used for serialization of public // keys. -#[derive(Clone, Copy)] +#[derive(Clone, Copy, PartialEq, Eq)] pub struct PointP256 { x: GFP256, y: GFP256, @@ -548,12 +548,6 @@ impl core::fmt::Debug for PointP256 { } } -impl PartialEq for PointP256 { - fn eq(&self, other: &PointP256) -> bool { - self.x == other.x && self.y == other.y - } -} - #[cfg(test)] pub mod test { use super::*; diff --git a/libraries/crypto/src/ecdsa.rs b/libraries/crypto/src/ecdsa.rs index 13d3577..b139ba0 100644 --- a/libraries/crypto/src/ecdsa.rs +++ b/libraries/crypto/src/ecdsa.rs @@ -33,12 +33,13 @@ pub struct SecKey { k: NonZeroExponentP256, } +#[derive(Clone, Debug, PartialEq, Eq)] pub struct Signature { r: NonZeroExponentP256, s: NonZeroExponentP256, } -#[derive(Clone)] +#[derive(Clone, Debug, PartialEq, Eq)] pub struct PubKey { p: PointP256, } diff --git a/libraries/crypto/src/hybrid.rs b/libraries/crypto/src/hybrid.rs new file mode 100644 index 0000000..1c0f221 --- /dev/null +++ b/libraries/crypto/src/hybrid.rs @@ -0,0 +1,246 @@ +// Copyright 2021-2022 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +use super::ecdsa; +use alloc::vec::Vec; + +// A label generated uniformly at random from the output space of SHA256. +const LABEL: [u8; 32] = [ + 43, 253, 32, 250, 19, 51, 24, 237, 138, 49, 47, 182, 4, 194, 133, 183, 177, 218, 115, 58, 92, + 117, 45, 172, 156, 5, 214, 176, 248, 103, 55, 216, +]; + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct SecKey { + dilithium_seed: [u8; dilithium::params::SEEDBYTES], + ecdsa_sk: ecdsa::SecKey, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct PubKey { + pub dilithium_pk: dilithium::sign::PubKey, + pub ecdsa_pk: ecdsa::PubKey, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct Signature { + pub dilithium_sign: Vec, + pub ecdsa_sign: ecdsa::Signature, +} + +fn ecdsa_input(msg: &[u8]) -> Vec { + let mut input = LABEL.to_vec(); + input.extend(msg); + return input; +} + +fn dilithium_input(msg: &[u8], ecdsa_sign: &ecdsa::Signature) -> Vec { + let mut input = LABEL.to_vec(); + input.extend(msg); + input.extend(ecdsa_sign.to_asn1_der()); + return input; +} + +impl SecKey { + pub const BYTES_LENGTH: usize = 32 + dilithium::params::SEEDBYTES; + pub fn gensk(rng: &mut R) -> SecKey + where + R: rng256::Rng256, + { + let mut seed = [0u8; dilithium::params::SEEDBYTES]; + rng.fill_bytes(&mut seed); + SecKey { + dilithium_seed: seed, + ecdsa_sk: ecdsa::SecKey::gensk(rng), + } + } + + pub fn gensk_with_pk(rng: &mut R) -> (SecKey, PubKey) + where + R: rng256::Rng256, + { + let mut seed = [0u8; dilithium::params::SEEDBYTES]; + rng.fill_bytes(&mut seed); + let (_, dilithium_pk) = dilithium::sign::SecKey::gensk_with_pk_from_seed(&seed); + let ecdsa_sk = ecdsa::SecKey::gensk(rng); + let ecdsa_pk = ecdsa_sk.genpk(); + let sk = SecKey { + dilithium_seed: seed, + ecdsa_sk, + }; + let pk = PubKey { + dilithium_pk, + ecdsa_pk, + }; + (sk, pk) + } + + pub fn genpk(&self) -> PubKey { + let (_, dilithium_pk) = + dilithium::sign::SecKey::gensk_with_pk_from_seed(&self.dilithium_seed); + PubKey { + dilithium_pk, + ecdsa_pk: self.ecdsa_sk.genpk(), + } + } + + pub fn sign_rfc6979(&self, msg: &[u8]) -> Signature + where + H: super::Hash256 + super::HashBlockSize64Bytes, + { + let ecdsa_sign = self.ecdsa_sk.sign_rfc6979::(&ecdsa_input(&msg)); + let dilithium_sk = dilithium::sign::SecKey::gensk_from_seed(&self.dilithium_seed); + // This wastes some stack, we could revert the Dilithium API to take a &mut [u8]. + let dilithium_sign = dilithium_sk + .sign(&dilithium_input(&msg, &ecdsa_sign)) + .to_vec(); + + return Signature { + ecdsa_sign, + dilithium_sign, + }; + } + + pub fn from_bytes(bytes: &[u8; SecKey::BYTES_LENGTH]) -> Option { + let ecdsa_bytes = array_ref!(bytes, 0, 32); + let ecdsa_sk = ecdsa::SecKey::from_bytes(&ecdsa_bytes)?; + + let dilithium_seed = array_ref!(bytes, 32, dilithium::params::SEEDBYTES).clone(); + + return Some(SecKey { + ecdsa_sk, + dilithium_seed, + }); + } + + pub fn to_bytes(&self, bytes: &mut [u8; SecKey::BYTES_LENGTH]) { + let mut ecdsa_bytes = array_mut_ref!(bytes, 0, 32); + self.ecdsa_sk.to_bytes(&mut ecdsa_bytes); + let dilithium_bytes = array_mut_ref!(bytes, 32, dilithium::params::SEEDBYTES); + dilithium_bytes.copy_from_slice(&self.dilithium_seed); + } +} + +impl PubKey { + pub const BYTES_LENGTH: usize = 2 * ecdsa::NBYTES + dilithium::params::PK_SIZE_PACKED; + + pub fn from_bytes(bytes: &[u8; PubKey::BYTES_LENGTH]) -> Option { + let ecdsa_x_bytes = array_ref!(bytes, 0, ecdsa::NBYTES); + let ecdsa_y_bytes = array_ref!(bytes, ecdsa::NBYTES, ecdsa::NBYTES); + + let ecdsa_pk = ecdsa::PubKey::from_coordinates(&ecdsa_x_bytes, &ecdsa_y_bytes)?; + + let dilithium_bytes = array_ref!( + bytes, + ecdsa::NBYTES + ecdsa::NBYTES, + dilithium::params::PK_SIZE_PACKED + ) + .clone(); + let dilithium_pk = dilithium::sign::PubKey::from_bytes(&dilithium_bytes); + + Some(PubKey { + ecdsa_pk, + dilithium_pk, + }) + } + + pub fn to_bytes(&self, bytes: &mut [u8; PubKey::BYTES_LENGTH]) { + let mut ecdsa_x_bytes = [0; ecdsa::NBYTES]; + let mut ecdsa_y_bytes = [0; ecdsa::NBYTES]; + self.ecdsa_pk + .to_coordinates(&mut ecdsa_x_bytes, &mut ecdsa_y_bytes); + array_mut_ref!(bytes, 0, ecdsa::NBYTES).clone_from(&ecdsa_x_bytes); + array_mut_ref!(bytes, ecdsa::NBYTES, ecdsa::NBYTES).clone_from(&ecdsa_y_bytes); + let mut dilithium_bytes = array_mut_ref!( + bytes, + ecdsa::NBYTES + ecdsa::NBYTES, + dilithium::params::PK_SIZE_PACKED + ); + self.dilithium_pk.to_bytes(&mut dilithium_bytes); + } + + pub fn verify_vartime(&self, msg: &[u8], sign: &Signature) -> bool + where + H: super::Hash256, + { + return self + .ecdsa_pk + .verify_hash_vartime(&H::hash(&ecdsa_input(&msg)), &sign.ecdsa_sign) + && self.dilithium_pk.verify( + &dilithium_input(&msg, &sign.ecdsa_sign), + array_ref!(sign.dilithium_sign, 0, dilithium::params::SIG_SIZE_PACKED), + ); + } +} + +impl Signature { + pub const BYTES_LENGTH: usize = 64 + dilithium::params::SIG_SIZE_PACKED; + + /// Converts a signature into the CBOR required byte array representation. + /// + /// This operation consumes the signature to efficiently use memory. + pub fn to_asn1_der(self) -> Vec { + let mut bytes = self.ecdsa_sign.to_asn1_der(); + bytes.reserve_exact(dilithium::params::SIG_SIZE_PACKED); + bytes.extend(self.dilithium_sign.into_iter()); + bytes + } +} + +#[cfg(test)] +mod test { + extern crate rng256; + use super::super::sha256::Sha256; + use super::*; + use rng256::Rng256; + + pub const ITERATIONS: u32 = 500; + + #[test] + fn test_hybrid_seckey_to_bytes_from_bytes() { + let mut rng = rng256::ThreadRng256 {}; + for _ in 0..ITERATIONS { + let sk = SecKey::gensk(&mut rng); + let mut bytes = [0; SecKey::BYTES_LENGTH]; + sk.to_bytes(&mut bytes); + let decoded_sk = SecKey::from_bytes(&bytes); + assert_eq!(decoded_sk, Some(sk)); + } + } + + #[test] + fn test_hybrid_pubkey_to_bytes_from_bytes() { + let mut rng = rng256::ThreadRng256 {}; + for _ in 0..ITERATIONS { + let sk = SecKey::gensk(&mut rng); + let pk = sk.genpk(); + let mut bytes = [0; PubKey::BYTES_LENGTH]; + pk.to_bytes(&mut bytes); + let decoded_pk = PubKey::from_bytes(&bytes); + assert_eq!(decoded_pk, Some(pk)); + } + } + + #[test] + fn test_hybrid_sign_rfc6979_verify_vartime() { + let mut rng = rng256::ThreadRng256 {}; + for _ in 0..ITERATIONS { + let msg = rng.gen_uniform_u8x32(); + let sk = SecKey::gensk(&mut rng); + let pk = sk.genpk(); + let sign = sk.sign_rfc6979::(&msg); + assert!(pk.verify_vartime::(&msg, &sign)); + } + } +} diff --git a/libraries/crypto/src/lib.rs b/libraries/crypto/src/lib.rs index 6a8e103..727ad93 100644 --- a/libraries/crypto/src/lib.rs +++ b/libraries/crypto/src/lib.rs @@ -1,4 +1,4 @@ -// Copyright 2019 Google LLC +// Copyright 2019-2022 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. @@ -16,6 +16,8 @@ #![feature(wrapping_int_impl)] extern crate alloc; +#[macro_use] +extern crate arrayref; pub mod aes256; pub mod cbc; @@ -24,6 +26,7 @@ pub mod ecdh; pub mod ecdsa; pub mod hkdf; pub mod hmac; +pub mod hybrid; pub mod sha256; pub mod util; diff --git a/libraries/rng256/src/lib.rs b/libraries/rng256/src/lib.rs index 398b091..0d4d3d7 100644 --- a/libraries/rng256/src/lib.rs +++ b/libraries/rng256/src/lib.rs @@ -21,6 +21,8 @@ use rand::Rng; // Lightweight RNG trait to generate uniformly distributed 256 bits. pub trait Rng256 { + fn fill_bytes(&mut self, buf: &mut [u8]); + fn gen_uniform_u8x32(&mut self) -> [u8; 32]; fn gen_uniform_u32x8(&mut self) -> [u32; 8] { @@ -45,6 +47,10 @@ fn bytes_to_u32(bytes: [u8; 32]) -> [u32; 8] { pub struct TockRng256 {} impl Rng256 for TockRng256 { + fn fill_bytes(&mut self, buf: &mut [u8]) { + libtock_drivers::rng::fill_buffer(buf); + } + fn gen_uniform_u8x32(&mut self) -> [u8; 32] { let mut buf: [u8; 32] = [Default::default(); 32]; rng::fill_buffer(&mut buf); @@ -58,6 +64,11 @@ pub struct ThreadRng256 {} #[cfg(feature = "std")] impl Rng256 for ThreadRng256 { + fn fill_bytes(&mut self, buf: &mut [u8]) { + let mut rng = rand::thread_rng(); + rng.fill(buf); + } + fn gen_uniform_u8x32(&mut self) -> [u8; 32] { let mut rng = rand::thread_rng(); let mut result = [Default::default(); 32]; diff --git a/nrf52840_layout.ld b/nrf52840_layout.ld index 8292738..538a2a8 100644 --- a/nrf52840_layout.ld +++ b/nrf52840_layout.ld @@ -14,7 +14,7 @@ MEMORY { * Any change to STACK_SIZE should be accompanied by a corresponding change to * `elf2tab`'s `--stack` option */ -STACK_SIZE = 16384; +STACK_SIZE = 71680; MPU_MIN_ALIGN = 8K; diff --git a/patches/libtock-rs/02-compiler-version.patch b/patches/libtock-rs/02-compiler-version.patch new file mode 100644 index 0000000..756e6ec --- /dev/null +++ b/patches/libtock-rs/02-compiler-version.patch @@ -0,0 +1,13 @@ +diff --git a/rust-toolchain b/rust-toolchain +index 1674405..2ba073e 100644 +--- a/rust-toolchain ++++ b/rust-toolchain +@@ -1,7 +1,7 @@ + [toolchain] + # See https://rust-lang.github.io/rustup-components-history/ for a list of + # recently nightlies and what components are available for them. +-channel = "nightly-2021-03-25" ++channel = "nightly-2021-06-25" + components = ["clippy", "miri", "rustfmt"] + targets = ["thumbv7em-none-eabi", + "riscv32imac-unknown-none-elf", diff --git a/patches/tock/07-app-break-fix.patch b/patches/tock/07-app-break-fix.patch index 738cf23..fcf46fd 100644 --- a/patches/tock/07-app-break-fix.patch +++ b/patches/tock/07-app-break-fix.patch @@ -7,7 +7,7 @@ index c78b1c9fb..2769d0138 100644 // The 1.x Tock kernel allocates at least 3 kB to processes, and we need // to ensure that happens as userspace may expect it. - 3 * 1024 -+ 16 * 1024 ++ 70 * 1024 // TOCK 2.0 // diff --git a/patches/tock/10-kernel-stack.patch b/patches/tock/10-kernel-stack.patch new file mode 100644 index 0000000..b6acd41 --- /dev/null +++ b/patches/tock/10-kernel-stack.patch @@ -0,0 +1,13 @@ +diff --git a/boards/nordic/nrf52840dk_opensk/src/main.rs b/boards/nordic/nrf52840dk_opensk/src/main.rs +index 83fd0bbab..53d623b46 100644 +--- a/boards/nordic/nrf52840dk_opensk/src/main.rs ++++ b/boards/nordic/nrf52840dk_opensk/src/main.rs +@@ -147,7 +147,7 @@ static mut CHIP: Option<&'static nrf52840::chip::NRF52 private_key, - CredentialSourceField::RpIdHash=> rp_id_hash, + CredentialSourceField::RpIdHash => rp_id_hash, CredentialSourceField::CredProtectPolicy => cred_protect_policy, CredentialSourceField::CredBlob => cred_blob, }; diff --git a/src/ctap/crypto_wrapper.rs b/src/ctap/crypto_wrapper.rs index 1f7bd1b..9c03d03 100644 --- a/src/ctap/crypto_wrapper.rs +++ b/src/ctap/crypto_wrapper.rs @@ -20,8 +20,8 @@ use alloc::vec; use alloc::vec::Vec; use core::convert::TryFrom; use crypto::cbc::{cbc_decrypt, cbc_encrypt}; -use crypto::ecdsa; use crypto::sha256::Sha256; +use crypto::{ecdsa, hybrid}; use rng256::Rng256; use sk_cbor as cbor; use sk_cbor::{cbor_array, cbor_bytes, cbor_int}; @@ -82,6 +82,7 @@ pub enum PrivateKey { Ecdsa([u8; 32]), #[cfg(feature = "ed25519")] Ed25519(ed25519_compact::SecretKey), + Hybrid(hybrid::SecKey), } impl PrivateKey { @@ -100,6 +101,34 @@ impl PrivateKey { let bytes = env.rng().gen_uniform_u8x32(); Self::new_ed25519_from_bytes(&bytes).unwrap() } + SignatureAlgorithm::Hybrid => PrivateKey::Hybrid(hybrid::SecKey::gensk(env.rng())), + SignatureAlgorithm::Unknown => unreachable!(), + } + } + + /// Creates a new private / public key pair for the given algorithm. + /// + /// # Panics + /// + /// Panics if the algorithm is [`SignatureAlgorithm::Unknown`]. + pub fn new_with_pub_key(env: &mut impl Env, alg: SignatureAlgorithm) -> (Self, CoseKey) { + match alg { + SignatureAlgorithm::Es256 => { + let private_key = PrivateKey::Ecdsa(env.key_store().generate_ecdsa_seed().unwrap()); + let pub_key = private_key.get_pub_key(env).unwrap(); + (private_key, pub_key) + } + #[cfg(feature = "ed25519")] + SignatureAlgorithm::Eddsa => { + let bytes = env.rng().gen_uniform_u8x32(); + let private_key = Self::new_ed25519_from_bytes(&bytes).unwrap(); + let pub_key = private_key.get_pub_key(env).unwrap(); + (private_key, pub_key) + } + SignatureAlgorithm::Hybrid => { + let (hybrid_key, pub_key) = hybrid::SecKey::gensk_with_pk(env.rng()); + (PrivateKey::Hybrid(hybrid_key), CoseKey::from(pub_key)) + } SignatureAlgorithm::Unknown => unreachable!(), } } @@ -137,6 +166,15 @@ impl PrivateKey { } } + /// Helper function that creates a private key of type Hybrid. + fn new_hybrid_from_bytes(bytes: &[u8]) -> Option { + if bytes.len() != hybrid::SecKey::BYTES_LENGTH { + return None; + } + hybrid::SecKey::from_bytes(array_ref!(bytes, 0, hybrid::SecKey::BYTES_LENGTH)) + .map(PrivateKey::from) + } + /// Returns the corresponding public key. pub fn get_pub_key(&self, env: &mut impl Env) -> Result { Ok(match self { @@ -145,6 +183,7 @@ impl PrivateKey { } #[cfg(feature = "ed25519")] PrivateKey::Ed25519(ed25519_key) => CoseKey::from(ed25519_key.public_key()), + PrivateKey::Hybrid(hybrid_key) => CoseKey::from(hybrid_key.genpk()), }) } @@ -160,6 +199,9 @@ impl PrivateKey { .to_asn1_der(), #[cfg(feature = "ed25519")] PrivateKey::Ed25519(ed25519_key) => ed25519_key.sign(message, None).to_vec(), + PrivateKey::Hybrid(hybrid_key) => { + hybrid_key.sign_rfc6979::(message).to_asn1_der() + } }) } @@ -169,6 +211,7 @@ impl PrivateKey { PrivateKey::Ecdsa(_) => SignatureAlgorithm::Es256, #[cfg(feature = "ed25519")] PrivateKey::Ed25519(_) => SignatureAlgorithm::Eddsa, + PrivateKey::Hybrid(_) => SignatureAlgorithm::Hybrid, } } @@ -178,6 +221,11 @@ impl PrivateKey { PrivateKey::Ecdsa(ecdsa_seed) => ecdsa_seed.to_vec(), #[cfg(feature = "ed25519")] PrivateKey::Ed25519(ed25519_key) => ed25519_key.seed().to_vec(), + PrivateKey::Hybrid(hybrid_key) => { + let mut key_bytes = vec![0u8; hybrid::SecKey::BYTES_LENGTH]; + hybrid_key.to_bytes(array_mut_ref!(key_bytes, 0, hybrid::SecKey::BYTES_LENGTH)); + key_bytes + } } } } @@ -214,11 +262,19 @@ impl TryFrom for PrivateKey { #[cfg(feature = "ed25519")] SignatureAlgorithm::Eddsa => PrivateKey::new_ed25519_from_bytes(&key_bytes) .ok_or(Ctap2StatusCode::CTAP2_ERR_INVALID_CBOR), + SignatureAlgorithm::Hybrid => PrivateKey::new_hybrid_from_bytes(&key_bytes) + .ok_or(Ctap2StatusCode::CTAP2_ERR_INVALID_CBOR), _ => Err(Ctap2StatusCode::CTAP2_ERR_INVALID_CBOR), } } } +impl From for PrivateKey { + fn from(hybrid_key: hybrid::SecKey) -> Self { + PrivateKey::Hybrid(hybrid_key) + } +} + #[cfg(test)] mod test { use super::*; diff --git a/src/ctap/data_formats.rs b/src/ctap/data_formats.rs index 9737bcf..d1c175f 100644 --- a/src/ctap/data_formats.rs +++ b/src/ctap/data_formats.rs @@ -15,21 +15,26 @@ use super::crypto_wrapper::PrivateKey; use super::status_code::Ctap2StatusCode; use alloc::string::String; +use alloc::vec; use alloc::vec::Vec; #[cfg(feature = "fuzz")] use arbitrary::Arbitrary; use arrayref::array_ref; use core::convert::TryFrom; -use crypto::{ecdh, ecdsa}; +use crypto::{ecdh, ecdsa, hybrid}; #[cfg(test)] use enum_iterator::IntoEnumIterator; -use sk_cbor as cbor; -use sk_cbor::{cbor_array_vec, cbor_map, cbor_map_options, destructure_cbor_map}; +use sk_cbor::{cbor_array_vec, cbor_bytes, cbor_map_options, destructure_cbor_map}; +use {dilithium, sk_cbor as cbor}; // Used as the identifier for ECDSA in assertion signatures and COSE. pub const ES256_ALGORITHM: i64 = -7; #[cfg(feature = "ed25519")] pub const EDDSA_ALGORITHM: i64 = -8; +// Used as the identifier for Hybrid in assertion signatures. +// (numbers less than -65536 are reserved for private use) +// TODO: Update this number later. +pub const HYBRID_ALGORITHM: i64 = -65537; // https://www.w3.org/TR/webauthn/#dictdef-publickeycredentialrpentity #[derive(Clone, Debug, PartialEq, Eq)] @@ -510,6 +515,7 @@ pub enum SignatureAlgorithm { Es256 = ES256_ALGORITHM as isize, #[cfg(feature = "ed25519")] Eddsa = EDDSA_ALGORITHM as isize, + Hybrid = HYBRID_ALGORITHM as isize, // This is the default for all numbers not covered above. // Unknown types should be ignored, instead of returning errors. Unknown = 0, @@ -527,6 +533,7 @@ impl From for SignatureAlgorithm { ES256_ALGORITHM => SignatureAlgorithm::Es256, #[cfg(feature = "ed25519")] EDDSA_ALGORITHM => SignatureAlgorithm::Eddsa, + HYBRID_ALGORITHM => SignatureAlgorithm::Hybrid, _ => SignatureAlgorithm::Unknown, } } @@ -733,6 +740,7 @@ pub struct CoseKey { algorithm: i64, key_type: i64, curve: i64, + dilithium_bytes: Option>, } impl CoseKey { @@ -744,6 +752,8 @@ impl CoseKey { const EC2_KEY_TYPE: i64 = 2; #[cfg(feature = "ed25519")] const OKP_KEY_TYPE: i64 = 1; + // The key type changes for hybrid. The value is made up. + const HYBRID_KEY_TYPE: i64 = -65537; // The parameter behind map key -1. const P_256_CURVE: i64 = 1; #[cfg(feature = "ed25519")] @@ -763,6 +773,7 @@ impl TryFrom for CoseKey { -1 => curve, -2 => x_bytes, -3 => y_bytes, + -4 => dilithium_bytes, } = extract_map(cbor_value)?; } @@ -785,16 +796,30 @@ impl TryFrom for CoseKey { return Err(Ctap2StatusCode::CTAP2_ERR_UNSUPPORTED_ALGORITHM); } let key_type = extract_integer(ok_or_missing(key_type)?)?; - if key_type != CoseKey::EC2_KEY_TYPE { + if key_type != CoseKey::EC2_KEY_TYPE && key_type != CoseKey::HYBRID_KEY_TYPE { return Err(Ctap2StatusCode::CTAP2_ERR_UNSUPPORTED_ALGORITHM); } + let parsed_dilithium_bytes = if key_type == CoseKey::EC2_KEY_TYPE { + if dilithium_bytes.is_some() { + return Err(Ctap2StatusCode::CTAP1_ERR_INVALID_PARAMETER); + } + None + } else { + let dilithium_bytes = extract_byte_string(ok_or_missing(dilithium_bytes)?)?; + if dilithium_bytes.len() != dilithium::params::PK_SIZE_PACKED { + return Err(Ctap2StatusCode::CTAP1_ERR_INVALID_PARAMETER); + } + Some(dilithium_bytes) + }; + Ok(CoseKey { x_bytes: *array_ref![x_bytes.as_slice(), 0, ecdh::NBYTES], y_bytes: *array_ref![y_bytes.as_slice(), 0, ecdh::NBYTES], algorithm, key_type, curve, + dilithium_bytes: parsed_dilithium_bytes, }) } } @@ -807,14 +832,16 @@ impl From for cbor::Value { algorithm, key_type, curve, + dilithium_bytes, } = cose_key; - cbor_map! { - 1 => key_type, - 3 => algorithm, - -1 => curve, - -2 => x_bytes, - -3 => y_bytes, + cbor_map_options! { + 1 => Some(key_type), + 3 => Some(algorithm), + -1 => Some(curve), + -2 => Some(cbor_bytes!(x_bytes.to_vec())), + -3 => Some(cbor_bytes!(y_bytes.to_vec())), + -4 => dilithium_bytes.map(|b| cbor_bytes!(b)), } } } @@ -830,6 +857,7 @@ impl From for CoseKey { algorithm: CoseKey::ECDH_ALGORITHM, key_type: CoseKey::EC2_KEY_TYPE, curve: CoseKey::P_256_CURVE, + dilithium_bytes: None, } } } @@ -845,6 +873,7 @@ impl From for CoseKey { algorithm: ES256_ALGORITHM, key_type: CoseKey::EC2_KEY_TYPE, curve: CoseKey::P_256_CURVE, + dilithium_bytes: None, } } } @@ -858,6 +887,27 @@ impl From for CoseKey { key_type: CoseKey::OKP_KEY_TYPE, curve: CoseKey::ED25519_CURVE, algorithm: EDDSA_ALGORITHM, + dilithium_bytes: None, + } + } +} + +impl From for CoseKey { + fn from(pk: hybrid::PubKey) -> Self { + let mut ecdsa_x_bytes = [0; ecdsa::NBYTES]; + let mut ecdsa_y_bytes = [0; ecdsa::NBYTES]; + pk.ecdsa_pk + .to_coordinates(&mut ecdsa_x_bytes, &mut ecdsa_y_bytes); + let mut dilithium_bytes = vec![0; dilithium::params::PK_SIZE_PACKED]; + let bytes_ref = array_mut_ref!(dilithium_bytes, 0, dilithium::params::PK_SIZE_PACKED); + pk.dilithium_pk.to_bytes(bytes_ref); + CoseKey { + x_bytes: ecdsa_x_bytes, + y_bytes: ecdsa_y_bytes, + key_type: CoseKey::EC2_KEY_TYPE, + curve: CoseKey::P_256_CURVE, + algorithm: ES256_ALGORITHM, + dilithium_bytes: Some(dilithium_bytes), } } } @@ -872,6 +922,7 @@ impl TryFrom for ecdh::PubKey { algorithm, key_type, curve, + dilithium_bytes, } = cose_key; // Since algorithm can be used for different COSE key types, we check @@ -884,6 +935,9 @@ impl TryFrom for ecdh::PubKey { if key_type != CoseKey::EC2_KEY_TYPE || curve != CoseKey::P_256_CURVE { return Err(Ctap2StatusCode::CTAP2_ERR_UNSUPPORTED_ALGORITHM); } + if dilithium_bytes.is_some() { + return Err(Ctap2StatusCode::CTAP1_ERR_INVALID_PARAMETER); + } ecdh::PubKey::from_coordinates(&x_bytes, &y_bytes) .ok_or(Ctap2StatusCode::CTAP1_ERR_INVALID_PARAMETER) } @@ -899,6 +953,7 @@ impl TryFrom for ecdsa::PubKey { algorithm, key_type, curve, + dilithium_bytes, } = cose_key; if algorithm != ES256_ALGORITHM @@ -907,6 +962,9 @@ impl TryFrom for ecdsa::PubKey { { return Err(Ctap2StatusCode::CTAP2_ERR_UNSUPPORTED_ALGORITHM); } + if dilithium_bytes.is_some() { + return Err(Ctap2StatusCode::CTAP1_ERR_INVALID_PARAMETER); + } ecdsa::PubKey::from_coordinates(&x_bytes, &y_bytes) .ok_or(Ctap2StatusCode::CTAP1_ERR_INVALID_PARAMETER) } @@ -1242,7 +1300,7 @@ mod test { use super::*; use crate::env::test::TestEnv; use cbor::{ - cbor_array, cbor_bool, cbor_bytes, cbor_bytes_lit, cbor_false, cbor_int, cbor_null, + cbor_array, cbor_bool, cbor_bytes_lit, cbor_false, cbor_int, cbor_map, cbor_null, cbor_text, cbor_unsigned, }; use rng256::Rng256; diff --git a/src/ctap/mod.rs b/src/ctap/mod.rs index 156ac12..865e2d6 100644 --- a/src/ctap/mod.rs +++ b/src/ctap/mod.rs @@ -114,8 +114,6 @@ pub const U2F_VERSION_STRING: &str = "U2F_V2"; // TODO(#106) change to final string when ready pub const FIDO2_1_VERSION_STRING: &str = "FIDO_2_1_PRE"; -// We currently only support one algorithm for signatures: ES256. -// This algorithm is requested in MakeCredential and advertized in GetInfo. pub const ES256_CRED_PARAM: PublicKeyCredentialParameter = PublicKeyCredentialParameter { cred_type: PublicKeyCredentialType::PublicKey, alg: SignatureAlgorithm::Es256, @@ -127,10 +125,16 @@ pub const EDDSA_CRED_PARAM: PublicKeyCredentialParameter = PublicKeyCredentialPa alg: SignatureAlgorithm::Eddsa, }; +pub const HYBRID_CRED_PARAM: PublicKeyCredentialParameter = PublicKeyCredentialParameter { + cred_type: PublicKeyCredentialType::PublicKey, + alg: SignatureAlgorithm::Hybrid, +}; + const SUPPORTED_CRED_PARAMS: &[PublicKeyCredentialParameter] = &[ ES256_CRED_PARAM, #[cfg(feature = "ed25519")] EDDSA_CRED_PARAM, + HYBRID_CRED_PARAM, ]; fn get_preferred_cred_param( @@ -261,6 +265,8 @@ fn send_keepalive_up_needed( } match processed_packet { ProcessedPacket::InitPacket { cmd, .. } => { + // Clippy doesn't understand the macro. + #[allow(clippy::branches_sharing_code)] if cmd == CtapHidCommand::Cancel as u8 { // We ignore the payload, we can't answer with an error code anyway. debug_ctap!(env, "User presence check cancelled"); @@ -848,7 +854,7 @@ impl CtapState { // We decide on the algorithm early, but delay key creation since it takes time. // We rather do that later so all intermediate checks may return faster. - let private_key = PrivateKey::new(env, algorithm); + let (private_key, public_cose_key) = PrivateKey::new_with_pub_key(env, algorithm); let credential_id = if options.rk { let random_id = env.rng().gen_uniform_u8x32().to_vec(); let credential_source = PublicKeyCredentialSource { @@ -887,13 +893,11 @@ impl CtapState { let mut auth_data = self.generate_auth_data(env, &rp_id_hash, flags)?; auth_data.extend(&storage::aaguid(env)?); - // The length is fixed to 0x20 or 0x80 and fits one byte. - if credential_id.len() > 0xFF { - return Err(Ctap2StatusCode::CTAP2_ERR_VENDOR_INTERNAL_ERROR); - } - auth_data.extend(vec![0x00, credential_id.len() as u8]); + auth_data.extend(vec![ + (credential_id.len() >> 8) as u8, + credential_id.len() as u8, + ]); auth_data.extend(&credential_id); - let public_cose_key = private_key.get_pub_key(env)?; cbor_write(cbor::Value::from(public_cose_key), &mut auth_data)?; if has_extension_output { let hmac_secret_output = if extensions.hmac_secret { @@ -943,7 +947,20 @@ impl CtapState { Some(vec![certificate]), ) } - None => (private_key.sign_and_encode(env, &signature_data)?, None), + None => { + if matches!(algorithm, SignatureAlgorithm::Hybrid) { + // We can't attest with Dilithium due to message size limits. + let new_ecdsa_key = ecdsa::SecKey::gensk(env.rng()); + ( + new_ecdsa_key + .sign_rfc6979::(&signature_data) + .to_asn1_der(), + None, + ) + } else { + (private_key.sign_and_encode(env, &signature_data)?, None) + } + } }; let attestation_statement = PackedAttestationStatement { alg: SignatureAlgorithm::Es256 as i64, diff --git a/src/env/test/mod.rs b/src/env/test/mod.rs index 163b5e6..f1b8d25 100644 --- a/src/env/test/mod.rs +++ b/src/env/test/mod.rs @@ -50,6 +50,10 @@ impl TestRng256 { } impl Rng256 for TestRng256 { + fn fill_bytes(&mut self, buf: &mut [u8]) { + self.rng.fill(buf) + } + fn gen_uniform_u8x32(&mut self) -> [u8; 32] { let mut result = [Default::default(); 32]; self.rng.fill(&mut result); diff --git a/src/env/tock/mod.rs b/src/env/tock/mod.rs index ca05027..3871906 100644 --- a/src/env/tock/mod.rs +++ b/src/env/tock/mod.rs @@ -117,7 +117,7 @@ impl UserPresence for TockEnv { } fn wait_with_timeout(&mut self, timeout: Milliseconds) -> UserPresenceResult { if timeout.integer() == 0 { - return Err(UserPresenceError::Timeout); + return Ok(()); } blink_leds(self.blink_pattern); self.blink_pattern += 1; diff --git a/src/env/tock/storage.rs b/src/env/tock/storage.rs index b2d7e29..560cd35 100644 --- a/src/env/tock/storage.rs +++ b/src/env/tock/storage.rs @@ -379,7 +379,7 @@ impl UpgradeStorage for TockUpgradeStorage { // Case: Last slice is written. if data.len() == self.partition.length() - offset { let metadata = unsafe { read_slice(self.metadata.start(), self.metadata.length()) }; - self.check_partition_hash(&metadata)?; + self.check_partition_hash(metadata)?; } Ok(()) } diff --git a/src/main.rs b/src/main.rs index 6688627..5657ea7 100644 --- a/src/main.rs +++ b/src/main.rs @@ -49,7 +49,7 @@ use libtock_drivers::timer::Duration; use libtock_drivers::usb_ctap_hid; use usb_ctap_hid::UsbEndpoint; -libtock_core::stack_size! {0x4000} +libtock_core::stack_size! {0x11800} const SEND_TIMEOUT: Milliseconds = Milliseconds(1000); const KEEPALIVE_DELAY_TOCK: Duration = Duration::from_ms(KEEPALIVE_DELAY_MS as isize); diff --git a/third_party/dilithium/Cargo.lock b/third_party/dilithium/Cargo.lock new file mode 100644 index 0000000..35d6953 --- /dev/null +++ b/third_party/dilithium/Cargo.lock @@ -0,0 +1,957 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 3 + +[[package]] +name = "ansi_term" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d52a9bb7ec0cf484c551830a7ce27bd20d67eac647e1befb56b0be4ee39a55d2" +dependencies = [ + "winapi", +] + +[[package]] +name = "arrayref" +version = "0.3.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a4c527152e37cf757a3f78aae5a06fbeefdb07ccc535c980a3208ee3060dd544" + +[[package]] +name = "atty" +version = "0.2.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8" +dependencies = [ + "hermit-abi", + "libc", + "winapi", +] + +[[package]] +name = "autocfg" +version = "0.1.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0dde43e75fd43e8a1bf86103336bc699aa8d17ad1be60c76c0bdfd4828e19b78" +dependencies = [ + "autocfg 1.1.0", +] + +[[package]] +name = "autocfg" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa" + +[[package]] +name = "bitflags" +version = "1.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" + +[[package]] +name = "block-buffer" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a076c298b9ecdb530ed9d967e74a6027d6a7478924520acddcddc24c1c8ab3ab" +dependencies = [ + "arrayref", + "byte-tools", +] + +[[package]] +name = "bstr" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ba3569f383e8f1598449f1a423e72e99569137b47740b1da11ef19af3d5c3223" +dependencies = [ + "lazy_static", + "memchr", + "regex-automata", + "serde", +] + +[[package]] +name = "bumpalo" +version = "3.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f1e260c3a9040a7c19a12468758f4c16f31a81a1fe087482be9570ec864bb6c" + +[[package]] +name = "byte-tools" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "560c32574a12a89ecd91f5e742165893f86e3ab98d21f8ea548658eb9eef5f40" + +[[package]] +name = "byteorder" +version = "1.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610" + +[[package]] +name = "cast" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5" + +[[package]] +name = "cfg-if" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" + +[[package]] +name = "clap" +version = "2.34.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a0610544180c38b88101fecf2dd634b174a62eef6946f84dfc6a7127512b381c" +dependencies = [ + "ansi_term", + "atty", + "bitflags", + "strsim", + "textwrap", + "unicode-width", + "vec_map", +] + +[[package]] +name = "cloudabi" +version = "0.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ddfc5b9aa5d4507acaf872de71051dfd0e309860e88966e1051e462a077aac4f" +dependencies = [ + "bitflags", +] + +[[package]] +name = "criterion" +version = "0.3.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b01d6de93b2b6c65e17c634a26653a29d107b3c98c607c765bf38d041531cd8f" +dependencies = [ + "atty", + "cast", + "clap", + "criterion-plot", + "csv", + "itertools 0.10.5", + "lazy_static", + "num-traits", + "oorandom", + "plotters", + "rayon", + "regex", + "serde", + "serde_cbor", + "serde_derive", + "serde_json", + "tinytemplate", + "walkdir", +] + +[[package]] +name = "criterion-plot" +version = "0.4.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2673cc8207403546f45f5fd319a974b1e6983ad1a3ee7e6041650013be041876" +dependencies = [ + "cast", + "itertools 0.10.5", +] + +[[package]] +name = "crossbeam-channel" +version = "0.5.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c2dd04ddaf88237dc3b8d8f9a3c1004b506b54b3313403944054d23c0870c521" +dependencies = [ + "cfg-if", + "crossbeam-utils", +] + +[[package]] +name = "crossbeam-deque" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "715e8152b692bba2d374b53d4875445368fdf21a94751410af607a5ac677d1fc" +dependencies = [ + "cfg-if", + "crossbeam-epoch", + "crossbeam-utils", +] + +[[package]] +name = "crossbeam-epoch" +version = "0.9.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f916dfc5d356b0ed9dae65f1db9fc9770aa2851d2662b988ccf4fe3516e86348" +dependencies = [ + "autocfg 1.1.0", + "cfg-if", + "crossbeam-utils", + "memoffset", + "scopeguard", +] + +[[package]] +name = "crossbeam-utils" +version = "0.8.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "edbafec5fa1f196ca66527c1b12c2ec4745ca14b50f1ad8f9f6f720b55d11fac" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "csv" +version = "1.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "22813a6dc45b335f9bade10bf7271dc477e81113e89eb251a0bc2a8a81c536e1" +dependencies = [ + "bstr", + "csv-core", + "itoa 0.4.8", + "ryu", + "serde", +] + +[[package]] +name = "csv-core" +version = "0.1.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2b2466559f260f48ad25fe6317b3c8dac77b5bdb5763ac7d9d6103530663bc90" +dependencies = [ + "memchr", +] + +[[package]] +name = "digest" +version = "0.7.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "03b072242a8cbaf9c145665af9d250c59af3b958f83ed6824e13533cf76d5b90" +dependencies = [ + "generic-array", +] + +[[package]] +name = "dilithium" +version = "0.2.0-alpha.3" +dependencies = [ + "arrayref", + "byteorder", + "criterion", + "digest", + "hex", + "itertools 0.7.11", + "once_cell", + "rand_core 0.6.4", + "rng256", + "sha3", + "structopt", +] + +[[package]] +name = "either" +version = "1.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "90e5c1c8368803113bf0c9584fc495a58b86dc8a29edbf8fe877d21d9507e797" + +[[package]] +name = "fuchsia-cprng" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a06f77d526c1a601b7c4cdd98f54b5eaabffc14d5f2f0296febdc7f357c6d3ba" + +[[package]] +name = "generic-array" +version = "0.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6d00328cedcac5e81c683e5620ca6a30756fc23027ebf9bff405c0e8da1fbb7e" +dependencies = [ + "typenum", +] + +[[package]] +name = "half" +version = "1.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eabb4a44450da02c90444cf74558da904edde8fb4e9035a9a6a4e15445af0bd7" + +[[package]] +name = "heck" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6d621efb26863f0e9924c6ac577e8275e5e6b77455db64ffa6c65c904e9e132c" +dependencies = [ + "unicode-segmentation", +] + +[[package]] +name = "hermit-abi" +version = "0.1.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33" +dependencies = [ + "libc", +] + +[[package]] +name = "hex" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "805026a5d0141ffc30abb3be3173848ad46a1b1664fe632428479619a3644d77" + +[[package]] +name = "itertools" +version = "0.7.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0d47946d458e94a1b7bcabbf6521ea7c037062c81f534615abcad76e84d4970d" +dependencies = [ + "either", +] + +[[package]] +name = "itertools" +version = "0.10.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473" +dependencies = [ + "either", +] + +[[package]] +name = "itoa" +version = "0.4.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b71991ff56294aa922b450139ee08b3bfc70982c6b2c7562771375cf73542dd4" + +[[package]] +name = "itoa" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4217ad341ebadf8d8e724e264f13e593e0648f5b3e94b3896a5df283be015ecc" + +[[package]] +name = "js-sys" +version = "0.3.60" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "49409df3e3bf0856b916e2ceaca09ee28e6871cf7d9ce97a692cacfdb2a25a47" +dependencies = [ + "wasm-bindgen", +] + +[[package]] +name = "keccak" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f9b7d56ba4a8344d6be9729995e6b06f928af29998cdf79fe390cbf6b1fee838" + +[[package]] +name = "lazy_static" +version = "1.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646" + +[[package]] +name = "libc" +version = "0.2.135" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "68783febc7782c6c5cb401fbda4de5a9898be1762314da0bb2c10ced61f18b0c" + +[[package]] +name = "libtock_codegen" +version = "0.1.0" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "libtock_core" +version = "0.1.0" +dependencies = [ + "libtock_codegen", +] + +[[package]] +name = "libtock_drivers" +version = "0.1.0" +dependencies = [ + "libtock_core", +] + +[[package]] +name = "log" +version = "0.4.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "abb12e687cfb44aa40f41fc3978ef76448f9b6038cad6aef4259d3c095a2382e" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "memchr" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d" + +[[package]] +name = "memoffset" +version = "0.6.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5aa361d4faea93603064a027415f07bd8e1d5c88c9fbf68bf56a285428fd79ce" +dependencies = [ + "autocfg 1.1.0", +] + +[[package]] +name = "num-traits" +version = "0.2.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd" +dependencies = [ + "autocfg 1.1.0", +] + +[[package]] +name = "num_cpus" +version = "1.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "19e64526ebdee182341572e50e9ad03965aa510cd94427a4549448f285e957a1" +dependencies = [ + "hermit-abi", + "libc", +] + +[[package]] +name = "once_cell" +version = "1.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2f7254b99e31cad77da24b08ebf628882739a608578bb1bcdfc1f9c21260d7c0" + +[[package]] +name = "oorandom" +version = "11.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ab1bc2a289d34bd04a330323ac98a1b4bc82c9d9fcb1e66b63caa84da26b575" + +[[package]] +name = "plotters" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2538b639e642295546c50fcd545198c9d64ee2a38620a628724a3b266d5fbf97" +dependencies = [ + "num-traits", + "plotters-backend", + "plotters-svg", + "wasm-bindgen", + "web-sys", +] + +[[package]] +name = "plotters-backend" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "193228616381fecdc1224c62e96946dfbc73ff4384fba576e052ff8c1bea8142" + +[[package]] +name = "plotters-svg" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f9a81d2759aae1dae668f783c308bc5c8ebd191ff4184aaa1b37f65a6ae5a56f" +dependencies = [ + "plotters-backend", +] + +[[package]] +name = "proc-macro-error" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c" +dependencies = [ + "proc-macro-error-attr", + "proc-macro2", + "quote", + "syn", + "version_check", +] + +[[package]] +name = "proc-macro-error-attr" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869" +dependencies = [ + "proc-macro2", + "quote", + "version_check", +] + +[[package]] +name = "proc-macro2" +version = "1.0.46" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "94e2ef8dbfc347b10c094890f778ee2e36ca9bb4262e86dc99cd217e35f3470b" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quote" +version = "1.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bbe448f377a7d6961e30f5955f9b8d106c3f5e449d493ee1b125c1d43c2b5179" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "rand" +version = "0.6.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6d71dacdc3c88c1fde3885a3be3fbab9f35724e6ce99467f7d9c5026132184ca" +dependencies = [ + "autocfg 0.1.8", + "libc", + "rand_chacha", + "rand_core 0.4.2", + "rand_hc", + "rand_isaac", + "rand_jitter", + "rand_os", + "rand_pcg", + "rand_xorshift", + "winapi", +] + +[[package]] +name = "rand_chacha" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "556d3a1ca6600bfcbab7c7c91ccb085ac7fbbcd70e008a98742e7847f4f7bcef" +dependencies = [ + "autocfg 0.1.8", + "rand_core 0.3.1", +] + +[[package]] +name = "rand_core" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7a6fdeb83b075e8266dcc8762c22776f6877a63111121f5f8c7411e5be7eed4b" +dependencies = [ + "rand_core 0.4.2", +] + +[[package]] +name = "rand_core" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9c33a3c44ca05fa6f1807d8e6743f3824e8509beca625669633be0acbdf509dc" + +[[package]] +name = "rand_core" +version = "0.6.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c" + +[[package]] +name = "rand_hc" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7b40677c7be09ae76218dc623efbf7b18e34bced3f38883af07bb75630a21bc4" +dependencies = [ + "rand_core 0.3.1", +] + +[[package]] +name = "rand_isaac" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ded997c9d5f13925be2a6fd7e66bf1872597f759fd9dd93513dd7e92e5a5ee08" +dependencies = [ + "rand_core 0.3.1", +] + +[[package]] +name = "rand_jitter" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1166d5c91dc97b88d1decc3285bb0a99ed84b05cfd0bc2341bdf2d43fc41e39b" +dependencies = [ + "libc", + "rand_core 0.4.2", + "winapi", +] + +[[package]] +name = "rand_os" +version = "0.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7b75f676a1e053fc562eafbb47838d67c84801e38fc1ba459e8f180deabd5071" +dependencies = [ + "cloudabi", + "fuchsia-cprng", + "libc", + "rand_core 0.4.2", + "rdrand", + "winapi", +] + +[[package]] +name = "rand_pcg" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "abf9b09b01790cfe0364f52bf32995ea3c39f4d2dd011eac241d2914146d0b44" +dependencies = [ + "autocfg 0.1.8", + "rand_core 0.4.2", +] + +[[package]] +name = "rand_xorshift" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cbf7e9e623549b0e21f6e97cf8ecf247c1a8fd2e8a992ae265314300b2455d5c" +dependencies = [ + "rand_core 0.3.1", +] + +[[package]] +name = "rayon" +version = "1.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bd99e5772ead8baa5215278c9b15bf92087709e9c1b2d1f97cdb5a183c933a7d" +dependencies = [ + "autocfg 1.1.0", + "crossbeam-deque", + "either", + "rayon-core", +] + +[[package]] +name = "rayon-core" +version = "1.9.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "258bcdb5ac6dad48491bb2992db6b7cf74878b0384908af124823d118c99683f" +dependencies = [ + "crossbeam-channel", + "crossbeam-deque", + "crossbeam-utils", + "num_cpus", +] + +[[package]] +name = "rdrand" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "678054eb77286b51581ba43620cc911abf02758c91f93f479767aed0f90458b2" +dependencies = [ + "rand_core 0.3.1", +] + +[[package]] +name = "regex" +version = "1.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4c4eb3267174b8c6c2f654116623910a0fef09c4753f8dd83db29c48a0df988b" +dependencies = [ + "regex-syntax", +] + +[[package]] +name = "regex-automata" +version = "0.1.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132" + +[[package]] +name = "regex-syntax" +version = "0.6.27" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a3f87b73ce11b1619a3c6332f45341e0047173771e8b8b73f87bfeefb7b56244" + +[[package]] +name = "rng256" +version = "0.1.0" +dependencies = [ + "arrayref", + "libtock_drivers", + "rand", +] + +[[package]] +name = "ryu" +version = "1.0.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4501abdff3ae82a1c1b477a17252eb69cee9e66eb915c1abaa4f44d873df9f09" + +[[package]] +name = "same-file" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502" +dependencies = [ + "winapi-util", +] + +[[package]] +name = "scopeguard" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd" + +[[package]] +name = "serde" +version = "1.0.145" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "728eb6351430bccb993660dfffc5a72f91ccc1295abaa8ce19b27ebe4f75568b" + +[[package]] +name = "serde_cbor" +version = "0.11.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2bef2ebfde456fb76bbcf9f59315333decc4fda0b2b44b420243c11e0f5ec1f5" +dependencies = [ + "half", + "serde", +] + +[[package]] +name = "serde_derive" +version = "1.0.145" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "81fa1584d3d1bcacd84c277a0dfe21f5b0f6accf4a23d04d4c6d61f1af522b4c" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "serde_json" +version = "1.0.86" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41feea4228a6f1cd09ec7a3593a682276702cd67b5273544757dae23c096f074" +dependencies = [ + "itoa 1.0.4", + "ryu", + "serde", +] + +[[package]] +name = "sha3" +version = "0.7.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b64dcef59ed4290b9fb562b53df07f564690d6539e8ecdd4728cf392477530bc" +dependencies = [ + "block-buffer", + "byte-tools", + "digest", + "keccak", +] + +[[package]] +name = "strsim" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8ea5119cdb4c55b55d432abb513a0429384878c15dde60cc77b1c99de1a95a6a" + +[[package]] +name = "structopt" +version = "0.3.26" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c6b5c64445ba8094a6ab0c3cd2ad323e07171012d9c98b0b15651daf1787a10" +dependencies = [ + "clap", + "lazy_static", + "structopt-derive", +] + +[[package]] +name = "structopt-derive" +version = "0.4.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dcb5ae327f9cc13b68763b5749770cb9e048a99bd9dfdfa58d0cf05d5f64afe0" +dependencies = [ + "heck", + "proc-macro-error", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "syn" +version = "1.0.102" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3fcd952facd492f9be3ef0d0b7032a6e442ee9b361d4acc2b1d0c4aaa5f613a1" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "textwrap" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060" +dependencies = [ + "unicode-width", +] + +[[package]] +name = "tinytemplate" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc" +dependencies = [ + "serde", + "serde_json", +] + +[[package]] +name = "typenum" +version = "1.15.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dcf81ac59edc17cc8697ff311e8f5ef2d99fcbd9817b34cec66f90b6c3dfd987" + +[[package]] +name = "unicode-ident" +version = "1.0.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ceab39d59e4c9499d4e5a8ee0e2735b891bb7308ac83dfb4e80cad195c9f6f3" + +[[package]] +name = "unicode-segmentation" +version = "1.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0fdbf052a0783de01e944a6ce7a8cb939e295b1e7be835a1112c3b9a7f047a5a" + +[[package]] +name = "unicode-width" +version = "0.1.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c0edd1e5b14653f783770bce4a4dabb4a5108a5370a5f5d8cfe8710c361f6c8b" + +[[package]] +name = "vec_map" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f1bddf1187be692e79c5ffeab891132dfb0f236ed36a43c7ed39f1165ee20191" + +[[package]] +name = "version_check" +version = "0.9.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f" + +[[package]] +name = "walkdir" +version = "2.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "808cf2735cd4b6866113f648b791c6adc5714537bc222d9347bb203386ffda56" +dependencies = [ + "same-file", + "winapi", + "winapi-util", +] + +[[package]] +name = "wasm-bindgen" +version = "0.2.83" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eaf9f5aceeec8be17c128b2e93e031fb8a4d469bb9c4ae2d7dc1888b26887268" +dependencies = [ + "cfg-if", + "wasm-bindgen-macro", +] + +[[package]] +name = "wasm-bindgen-backend" +version = "0.2.83" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4c8ffb332579b0557b52d268b91feab8df3615f265d5270fec2a8c95b17c1142" +dependencies = [ + "bumpalo", + "log", + "once_cell", + "proc-macro2", + "quote", + "syn", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-macro" +version = "0.2.83" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "052be0f94026e6cbc75cdefc9bae13fd6052cdcaf532fa6c45e7ae33a1e6c810" +dependencies = [ + "quote", + "wasm-bindgen-macro-support", +] + +[[package]] +name = "wasm-bindgen-macro-support" +version = "0.2.83" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "07bc0c051dc5f23e307b13285f9d75df86bfdf816c5721e573dec1f9b8aa193c" +dependencies = [ + "proc-macro2", + "quote", + "syn", + "wasm-bindgen-backend", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-shared" +version = "0.2.83" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1c38c045535d93ec4f0b4defec448e4291638ee608530863b1e2ba115d4fff7f" + +[[package]] +name = "web-sys" +version = "0.3.60" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bcda906d8be16e728fd5adc5b729afad4e444e106ab28cd1c7256e54fa61510f" +dependencies = [ + "js-sys", + "wasm-bindgen", +] + +[[package]] +name = "winapi" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" +dependencies = [ + "winapi-i686-pc-windows-gnu", + "winapi-x86_64-pc-windows-gnu", +] + +[[package]] +name = "winapi-i686-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" + +[[package]] +name = "winapi-util" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178" +dependencies = [ + "winapi", +] + +[[package]] +name = "winapi-x86_64-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" diff --git a/third_party/dilithium/Cargo.toml b/third_party/dilithium/Cargo.toml new file mode 100644 index 0000000..c96360a --- /dev/null +++ b/third_party/dilithium/Cargo.toml @@ -0,0 +1,34 @@ +[package] +name = "dilithium" +version = "0.2.0-alpha.3" +authors = ["quininer "] +description = "Digital Signatures from Module Lattices" +repository = "https://github.com/quininer/dilithium" +license = "MIT" + +[dependencies] +rng256 = { path = "../../libraries/rng256" } +rand_core = { version = "0.6", default-features = false } +arrayref = {version = "0.3", default-features = false} +itertools = { version = "0.7", default-features = false } +byteorder = { version = "1", default-features = false } +sha3 = { version = "0.7.3", default-features = false } +digest = { version = "0.7", default-features = false } + +[dev-dependencies] +hex = "0.3" +structopt = "0.3.25" +criterion = "0.3" + +[features] +std = [ "rng256/std" ] +default = [ "dilithium5", "optimize_stack" ] +dilithium2 = [] +dilithium3 = [] +dilithium5 = [] +optimize_stack = [] +derive_debug = [] + +[[bench]] +name = "sign_bench" +harness = false \ No newline at end of file diff --git a/third_party/dilithium/LICENSE b/third_party/dilithium/LICENSE new file mode 100644 index 0000000..6f1023a --- /dev/null +++ b/third_party/dilithium/LICENSE @@ -0,0 +1,8 @@ +MIT License +Copyright (c) 2017 quininer@live.com + +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/third_party/dilithium/README.md b/third_party/dilithium/README.md new file mode 100644 index 0000000..8c542e6 --- /dev/null +++ b/third_party/dilithium/README.md @@ -0,0 +1,7 @@ +Dilithium +--------- + +Digital Signatures from Module Lattices + +* [CRYSTALS – Dilithium: Digital Signatures from Module Lattices](https://eprint.iacr.org/2017/633.pdf) +* [ref dilithium implemention](https://github.com/pq-crystals/dilithium) diff --git a/third_party/dilithium/benches/sign_bench.rs b/third_party/dilithium/benches/sign_bench.rs new file mode 100644 index 0000000..0a61987 --- /dev/null +++ b/third_party/dilithium/benches/sign_bench.rs @@ -0,0 +1,70 @@ +// Benchmarks for key generation and signing with Dilithium. +// cargo criterion --features std + +extern crate core; +extern crate criterion; +extern crate dilithium; +extern crate rng256; + +use core::time::Duration; +use criterion::*; +use dilithium::sign::SecKey; +use rng256::Rng256; + +const SAMPLE_SIZE: usize = 1000; +const MEASUREMENT_TIME: Duration = Duration::from_secs(10); + +fn bench_sk(c: &mut Criterion) { + let mut rng = rng256::ThreadRng256 {}; + + c.bench_function("gensk", |b| { + b.iter_batched( + || {}, + |_| { + SecKey::gensk(&mut rng); + }, + BatchSize::SmallInput, + ) + }); +} + +fn bench_pk(c: &mut Criterion) { + let mut rng = rng256::ThreadRng256 {}; + + c.bench_function("genpk", |b| { + b.iter_batched( + || SecKey::gensk(&mut rng), + |sk| { + sk.genpk(); + }, + BatchSize::SmallInput, + ) + }); +} + +fn bench_sign(c: &mut Criterion) { + const MESSAGE_LENGTH: usize = 64; + let mut rng = rng256::ThreadRng256 {}; + + c.bench_function("sign", |b| { + b.iter_batched( + || { + let sk = SecKey::gensk(&mut rng); + let mut message = [0; MESSAGE_LENGTH]; + rng.fill_bytes(&mut message); + (sk, message) + }, + |(sk, message)| { + sk.sign(&message); + }, + BatchSize::SmallInput, + ) + }); +} + +criterion_group! { + name = benches; + config = Criterion::default().sample_size(SAMPLE_SIZE).measurement_time(MEASUREMENT_TIME); + targets = bench_sk, bench_pk, bench_sign +} +criterion_main!(benches); diff --git a/third_party/dilithium/examples/sign.rs b/third_party/dilithium/examples/sign.rs new file mode 100644 index 0000000..6f21fb9 --- /dev/null +++ b/third_party/dilithium/examples/sign.rs @@ -0,0 +1,41 @@ +// Command for changing the stack size: +// cargo run --example sign --features std -- --stack-size-kb (new value in KB) + +extern crate dilithium; +extern crate rng256; +extern crate structopt; + +use dilithium::sign::SecKey; +use rng256::Rng256; +use std::thread; +use structopt::StructOpt; + +const DEFAULT_STACK_SIZE_KB: &str = "81"; + +#[derive(Debug, StructOpt)] +struct Opts { + #[structopt(long, default_value=DEFAULT_STACK_SIZE_KB)] + stack_size_kb: usize, +} + +fn run() { + let mut rng = rng256::ThreadRng256 {}; + + let sk = SecKey::gensk(&mut rng); + let mut message = [0; 59]; + rng.fill_bytes(&mut message); + sk.sign(&message); +} + +fn main() { + let stack_size_kb = Opts::from_args().stack_size_kb; + + // We bound the stack size for generating keys and signing in Dilithium. + let child = thread::Builder::new() + .stack_size(stack_size_kb * 1024) + .spawn(run) + .unwrap(); + + // Wait for thread to join + child.join().unwrap(); +} diff --git a/third_party/dilithium/src/lib.rs b/third_party/dilithium/src/lib.rs new file mode 100644 index 0000000..d33d6a0 --- /dev/null +++ b/third_party/dilithium/src/lib.rs @@ -0,0 +1,25 @@ +#![cfg_attr(not(feature = "std"), no_std)] + +#[cfg(feature = "std")] +extern crate core; + +#[macro_use] +extern crate arrayref; +extern crate byteorder; +extern crate digest; +extern crate itertools; +extern crate sha3; + +#[macro_use] +mod utils; +mod ntt; +mod packing; +pub mod params; +mod poly; +mod polyvec; +mod reduce; +mod rounding; +pub mod sign; + +#[cfg(test)] +mod test_mul; diff --git a/third_party/dilithium/src/ntt.rs b/third_party/dilithium/src/ntt.rs new file mode 100644 index 0000000..536eb56 --- /dev/null +++ b/third_party/dilithium/src/ntt.rs @@ -0,0 +1,94 @@ +use itertools::Itertools; +use params::N; +use reduce::montgomery_reduce; + +const ZETAS: [i32; N] = [ + 0, 25847, -2608894, -518909, 237124, -777960, -876248, 466468, 1826347, 2353451, -359251, + -2091905, 3119733, -2884855, 3111497, 2680103, 2725464, 1024112, -1079900, 3585928, -549488, + -1119584, 2619752, -2108549, -2118186, -3859737, -1399561, -3277672, 1757237, -19422, 4010497, + 280005, 2706023, 95776, 3077325, 3530437, -1661693, -3592148, -2537516, 3915439, -3861115, + -3043716, 3574422, -2867647, 3539968, -300467, 2348700, -539299, -1699267, -1643818, 3505694, + -3821735, 3507263, -2140649, -1600420, 3699596, 811944, 531354, 954230, 3881043, 3900724, + -2556880, 2071892, -2797779, -3930395, -1528703, -3677745, -3041255, -1452451, 3475950, + 2176455, -1585221, -1257611, 1939314, -4083598, -1000202, -3190144, -3157330, -3632928, 126922, + 3412210, -983419, 2147896, 2715295, -2967645, -3693493, -411027, -2477047, -671102, -1228525, + -22981, -1308169, -381987, 1349076, 1852771, -1430430, -3343383, 264944, 508951, 3097992, + 44288, -1100098, 904516, 3958618, -3724342, -8578, 1653064, -3249728, 2389356, -210977, 759969, + -1316856, 189548, -3553272, 3159746, -1851402, -2409325, -177440, 1315589, 1341330, 1285669, + -1584928, -812732, -1439742, -3019102, -3881060, -3628969, 3839961, 2091667, 3407706, 2316500, + 3817976, -3342478, 2244091, -2446433, -3562462, 266997, 2434439, -1235728, 3513181, -3520352, + -3759364, -1197226, -3193378, 900702, 1859098, 909542, 819034, 495491, -1613174, -43260, + -522500, -655327, -3122442, 2031748, 3207046, -3556995, -525098, -768622, -3595838, 342297, + 286988, -2437823, 4108315, 3437287, -3342277, 1735879, 203044, 2842341, 2691481, -2590150, + 1265009, 4055324, 1247620, 2486353, 1595974, -3767016, 1250494, 2635921, -3548272, -2994039, + 1869119, 1903435, -1050970, -1333058, 1237275, -3318210, -1430225, -451100, 1312455, 3306115, + -1962642, -1279661, 1917081, -2546312, -1374803, 1500165, 777191, 2235880, 3406031, -542412, + -2831860, -1671176, -1846953, -2584293, -3724270, 594136, -3776993, -2013608, 2432395, 2454455, + -164721, 1957272, 3369112, 185531, -1207385, -3183426, 162844, 1616392, 3014001, 810149, + 1652634, -3694233, -1799107, -3038916, 3523897, 3866901, 269760, 2213111, -975884, 1717735, + 472078, -426683, 1723600, -1803090, 1910376, -1667432, -1104333, -260646, -3833893, -2939036, + -2235985, -420899, -2286327, 183443, -976891, 1612842, -3545687, -554416, 3919660, -48306, + -1362209, 3937738, 1400424, -846154, 1976782, +]; + +/// Implements forward NTT, in-place. +/// +/// No modular reduction is performed after additions or substractions. +/// The output vector is in bitreversed order. +/// +/// # Arguments +/// +/// * `p` - a polynomial in standard representation. +pub fn ntt(p: &mut [i32; N]) { + let mut k = 1; + let mut len = 128; + while len > 0 { + for start in Itertools::step(0..N, 2 * len) { + let zeta = i64::from(ZETAS[k]); + k += 1; + for j in start..(start + len) { + let t = montgomery_reduce(zeta * i64::from(p[j + len])); + p[j + len] = p[j] - t; + p[j] += t; + } + } + + len >>= 1; + } +} + +/// Implements inverse NTT and multiplication by Montgomery factor 2^32. +/// +/// The implementation is in-place. +/// No modular reduction is performed after additions or substractions. +/// Input coefficients must be smaller than Q in absolute value. +/// The output coefficients are smaller than Q in absolute value. +/// +/// # Arguments +/// +/// * `p` - a polynomial in NTT representation. +pub fn invntt_frominvmont(p: &mut [i32; N]) { + let mut k = 255; + let mut len = 1; + + while len < N { + for start in Itertools::step(0..N, 2 * len) { + let zeta = (-1) * i64::from(ZETAS[k]); + k -= 1; + + for j in start..(start + len) { + let t = p[j]; + p[j] += p[j + len]; + p[j + len] = t - p[j + len]; + p[j + len] = montgomery_reduce(zeta * i64::from(p[j + len])); + } + } + len <<= 1; + } + + // F = MONT^2 / 256 mod Q, where MONT = 2^32 mod Q. + const F: i64 = 41978; + for j in 0..N { + p[j] = montgomery_reduce(F * i64::from(p[j])); + } +} diff --git a/third_party/dilithium/src/packing.rs b/third_party/dilithium/src/packing.rs new file mode 100644 index 0000000..7d1f031 --- /dev/null +++ b/third_party/dilithium/src/packing.rs @@ -0,0 +1,164 @@ +use params::{ + K, L, N, OMEGA, PK_SIZE_PACKED, POLT1_SIZE_PACKED, POLZ_SIZE_PACKED, SEEDBYTES, SIG_SIZE_PACKED, +}; +use poly::{self, Poly}; +use polyvec::{PolyVecK, PolyVecL}; + +pub mod pk { + use super::*; + + /// Decodes a public key with the shape: `pk || rho || encodings of t1`. + /// + /// # Arguments + /// + /// * `pk` - the encoded public key + /// * `rho` - output array for the randomness seed `rho` + /// * `t1` - output PolyVecK for the vector of polynomials `t1` + pub fn unpack(pk: &[u8; PK_SIZE_PACKED], rho: &mut [u8; SEEDBYTES], t1: &mut PolyVecK) { + let (rho_bytes, t1s_bytes) = array_refs!(pk, SEEDBYTES, POLT1_SIZE_PACKED * K); + + rho.clone_from(rho_bytes); + for i in 0..K { + let t1_bytes = array_ref!(t1s_bytes, i * POLT1_SIZE_PACKED, POLT1_SIZE_PACKED); + poly::t1_unpack(&mut t1[i], t1_bytes); + } + } +} + +// Encodes and Decodes a signature with the shape: +// c_seed || encodings of z || encodings of h +pub mod sign { + use super::*; + + /// Encodes an array used to obtain the challenge `c`. + /// + /// # Arguments + /// + /// * `sig` - the output array representing the encoded signature + /// * `c_seed` - array to be encoded + pub fn pack_c(sign: &mut [u8; SIG_SIZE_PACKED], c_seed: &[u8; SEEDBYTES]) { + let c_bytes = array_mut_ref!(sign, 0, SEEDBYTES); + for i in 0..SEEDBYTES { + c_bytes[i] = c_seed[i]; + } + } + + /// Encodes `z[i]`, where z is a vector of `L` polynomials. + /// + /// # Arguments + /// + /// * `sig` - output array representing the encoded signature + /// * `z_component` - polynomial representing `z[i]` + /// * `i` - the index of the component to be encoded + pub fn pack_z_component(sign: &mut [u8; SIG_SIZE_PACKED], z_component: &Poly, i: usize) { + let z_bytes = array_mut_ref!(sign, SEEDBYTES + i * POLZ_SIZE_PACKED, POLZ_SIZE_PACKED); + poly::z_pack(z_bytes, &z_component); + } + + /// Encodes `z`, where `z` is a vector of `L` polynomials. + /// + /// # Arguments + /// + /// * `sig` - output array representing the encoded signature + /// * `z` - vector of `L` polynomials` + #[cfg(not(feature = "optimize_stack"))] + pub fn pack_z(sign: &mut [u8; SIG_SIZE_PACKED], z: &PolyVecL) { + for i in 0..L { + pack_z_component(sign, &z[i], i); + } + } + + /// Encodes `h[i]`, where `h` is a vector of `K` polynomials. + /// + /// # Arguments + /// + /// * `sig` - output array representing the encoded signature + /// * `h_component` - polynomial representing `h[i]` + /// * `i` - the index of the component to be encoded + /// * `non_zero_coeff_index` - the index returned when encoding + /// `h[i - 1]` (0 if `i` = 0) + pub fn pack_h_component( + sign: &mut [u8; SIG_SIZE_PACKED], + h_component: &Poly, + i: usize, + non_zero_coeff_index: &mut usize, + ) { + let h_bytes = array_mut_ref!(sign, SEEDBYTES + POLZ_SIZE_PACKED * L, OMEGA + K); + + for j in 0..N { + if h_component[j] != 0 { + h_bytes[*non_zero_coeff_index] = j as u8; + *non_zero_coeff_index += 1; + } + } + h_bytes[OMEGA + i] = *non_zero_coeff_index as u8; + } + + /// Encodes `h`, where `h` is a vector of `K` polynomials. + /// + /// # Arguments + /// + /// * `sig` - output array representing the encoded signature + /// * `h` - vector of `K` polynomials. + #[cfg(not(feature = "optimize_stack"))] + pub fn pack_h(sign: &mut [u8; SIG_SIZE_PACKED], h: &PolyVecK) { + let mut non_zero_coeff_index = 0; + for i in 0..K { + pack_h_component(sign, &h[i], i, &mut non_zero_coeff_index); + } + } + + /// Decodes the components of the signature. + /// + /// The values are written into the output arguments `c_seed`, + /// `z`, and `h` from `sig`. + /// + /// # Arguments + /// + /// * `sig` - the encoded signature + /// * `c_seed` - output array for the seed used to compute the challenge + /// * `z` - output PolyVecL for the vector of polynomials `z` + /// * `h` - output PolyVecK for the vector of polynomials `h` + pub fn unpack( + sign: &[u8; SIG_SIZE_PACKED], + c_seed: &mut [u8; SEEDBYTES], + z: &mut PolyVecL, + h: &mut PolyVecK, + ) -> bool { + let (c_bytes, z_bytes, h_bytes) = + array_refs!(sign, SEEDBYTES, POLZ_SIZE_PACKED * L, OMEGA + K); + + for i in 0..SEEDBYTES { + c_seed[i] = c_bytes[i]; + } + + for i in 0..L { + let z_bytes = array_ref!(z_bytes, i * POLZ_SIZE_PACKED, POLZ_SIZE_PACKED); + poly::z_unpack(&mut z[i], z_bytes); + } + + // Decode h + let mut k = 0; + for i in 0..K { + if (h_bytes[OMEGA + i] as usize) < k || (h_bytes[OMEGA + i] as usize) > OMEGA { + return false; + } + + for j in k..(h_bytes[OMEGA + i] as usize) { + // Coefficients are ordered for strong unforgeability + if j > k && h_bytes[j] <= h_bytes[j - 1] { + return false; + } + + h[i][h_bytes[j] as usize] = 1; + } + k = h_bytes[OMEGA + i] as usize; + } + // Extra indices are zero for strong unforgeability + if h_bytes[k..OMEGA].iter().any(|&v| v != 0) { + return false; + } + + true + } +} diff --git a/third_party/dilithium/src/params.rs b/third_party/dilithium/src/params.rs new file mode 100644 index 0000000..bed3854 --- /dev/null +++ b/third_party/dilithium/src/params.rs @@ -0,0 +1,78 @@ +#![cfg_attr(feature = "cargo-clippy", allow(unreadable_literal))] + +pub const SEEDBYTES: usize = 32; +pub const CRHBYTES: usize = 64; +pub const N: usize = 256; +pub const Q: i32 = 8380417; +pub const D: usize = 13; +pub const ROOT_OF_UNITY: usize = 1753; + +#[cfg(feature = "dilithium2")] +mod mode { + use super::Q; + pub const K: usize = 4; + pub const L: usize = 4; + pub const ETA: i32 = 2; + pub const TAU: usize = 39; + pub const BETA: i32 = 78; + pub const GAMMA1: i32 = 1 << 17; + pub const GAMMA2: i32 = (Q - 1) / 88; + pub const OMEGA: usize = 80; + + pub const POLZ_SIZE_PACKED: usize = 576; + pub const POLW1_SIZE_PACKED: usize = 192; + pub const POLETA_SIZE_PACKED: usize = 96; +} + +#[cfg(feature = "dilithium3")] +mod mode { + use super::Q; + pub const K: usize = 6; + pub const L: usize = 5; + pub const ETA: i32 = 4; + pub const TAU: usize = 49; + pub const BETA: i32 = 196; + pub const GAMMA1: i32 = 1 << 19; + pub const GAMMA2: i32 = (Q - 1) / 32; + pub const OMEGA: usize = 55; + + pub const POLZ_SIZE_PACKED: usize = 640; + pub const POLW1_SIZE_PACKED: usize = 128; + pub const POLETA_SIZE_PACKED: usize = 128; +} + +#[cfg(feature = "dilithium5")] +mod mode { + use super::Q; + pub const K: usize = 8; + pub const L: usize = 7; + pub const ETA: i32 = 2; + pub const TAU: usize = 60; + pub const BETA: i32 = 120; + pub const GAMMA1: i32 = 1 << 19; + pub const GAMMA2: i32 = (Q - 1) / 32; + pub const OMEGA: usize = 75; + + pub const POLZ_SIZE_PACKED: usize = 640; + pub const POLW1_SIZE_PACKED: usize = 128; + pub const POLETA_SIZE_PACKED: usize = 96; +} + +pub use self::mode::*; + +pub const POLT1_SIZE_PACKED: usize = 320; +pub const POLT0_SIZE_PACKED: usize = 416; + +pub const PK_SIZE_PACKED: usize = SEEDBYTES + K * POLT1_SIZE_PACKED; +pub const SK_SIZE_PACKED: usize = 3 * SEEDBYTES + (L + K) * POLETA_SIZE_PACKED; +pub const SK_SIZE_PACKED_ORIGINAL: usize = + 3 * SEEDBYTES + (L + K) * POLETA_SIZE_PACKED + K * POLT0_SIZE_PACKED; +pub const SIG_SIZE_PACKED: usize = L * POLZ_SIZE_PACKED + (OMEGA + K) + SEEDBYTES; + +pub const PUBLICKEYBYTES: usize = PK_SIZE_PACKED; +pub const SECRETKEYBYTES: usize = SK_SIZE_PACKED; +pub const BYTES: usize = SIG_SIZE_PACKED; + +/// `MONT = 2^32 mod Q` +pub const MONT: i64 = -4186625; +pub const QINV: isize = 58728449; diff --git a/third_party/dilithium/src/poly.rs b/third_party/dilithium/src/poly.rs new file mode 100644 index 0000000..c7a8732 --- /dev/null +++ b/third_party/dilithium/src/poly.rs @@ -0,0 +1,775 @@ +use byteorder::{ByteOrder, LittleEndian}; +pub use ntt::{invntt_frominvmont as invntt_montgomery, ntt}; +use params::{ + CRHBYTES, D, ETA, GAMMA1, GAMMA2, N, POLETA_SIZE_PACKED, POLT1_SIZE_PACKED, POLW1_SIZE_PACKED, + POLZ_SIZE_PACKED, Q, SEEDBYTES, TAU, +}; +use reduce::{caddq as xcaddq, freeze as xfreeze, montgomery_reduce, reduce32}; +use rounding; + +pub type Poly = [i32; N]; + +/// Reduces the coefficients of the polynomial `a` to [-6283009,6283007]. +/// +/// # Arguments +/// +/// * `a` - a polynomial +pub fn reduce(a: &mut Poly) { + for i in 0..N { + a[i] = reduce32(a[i]); + } +} + +/// Adds `Q` to every negative coefficient in `a`. +/// +/// # Arguments +/// +/// * `a` - a polynomial +pub fn caddq(a: &mut Poly) { + for i in 0..N { + a[i] = xcaddq(a[i]); + } +} + +/// For every coefficient `x` in `a`, computes `x mod Q`. +/// +/// # Arguments +/// +/// * `a` - a polynomial +pub fn freeze(a: &mut Poly) { + for i in 0..N { + a[i] = xfreeze(a[i]); + } +} + +/// Computes `c = a + b`, where `c`, `a`, and `b` are polynomials. +/// +/// # Arguments +/// +/// * `a` - a polynomial +pub fn add(c: &mut Poly, a: &Poly, b: &Poly) { + for i in 0..N { + c[i] = a[i] + b[i]; + } +} + +/// Computes `c = c + a`, where `c`, and `a` are polynomials. +/// +/// # Arguments +/// +/// * `a` - a polynomial +pub fn add_assign(c: &mut Poly, a: &Poly) { + for i in 0..N { + c[i] += a[i]; + } +} + +/// Computes `c = a - b`, where `c`, `a` and `b` are polynomials. +/// +/// # Arguments +/// +/// * `a` - a polynomial +pub fn sub(c: &mut Poly, a: &Poly, b: &Poly) { + for i in 0..N { + c[i] = a[i] - b[i]; + } +} + +/// Multiplies the polynomial `a` by `2^D` without modular reduction. +/// +/// # Arguments +/// +/// * `a` - a polynomial with coefficients smaller than than 2^{31-D} +/// in absolute value +pub fn shift_left(a: &mut Poly) { + for i in 0..N { + a[i] <<= D; + } +} + +/// Computes `c = a * b` in NTT domain representation. +/// +/// # Arguments +/// +/// * `c` - the output polynomial, in NTT domain representation +/// * `a` - a polynomial in NTT domain representation +/// * `b` - a polynomial in NTT domain representation +pub fn pointwise_invmontgomery(c: &mut Poly, a: &Poly, b: &Poly) { + for i in 0..N { + c[i] = montgomery_reduce((a[i] as i64) * (b[i] as i64)); + } +} + +/// Returns `c = a * b` in standard representation. +/// +/// # Arguments +/// +/// * `a` - a polynomial in NTT domain representation +/// * `b` - a polynomial in NTT domain representation +pub fn multiply(a: &Poly, b: &Poly) -> Poly { + let mut c = [0; N]; + pointwise_invmontgomery(&mut c, a, b); + invntt_montgomery(&mut c); + reduce(&mut c); + c +} + +/// Decomposes a into the quotient and remainder of its division with `2^{D-1}`. +/// +/// For every coefficient `c` of the polynomial `a`, computes `c0`, `c1` +/// such that `c mod Q = c1 * 2^D + c0`, with `-2^{D-1} < c0 <= 2^{D-1}`. +/// +/// # Arguments +/// +/// * `a` - a polynomial in standard representation (not NTT) +/// * `a0` - output polynomial representing the remainder (coefficients `c0`) +/// * `a1` - output polynomial representing the quotient (coefficients `c1`) +pub fn power2round(a: &Poly, a0: &mut Poly, a1: &mut Poly) { + for i in 0..N { + let (x, y) = rounding::power2round(a[i]); + a0[i] = x; + a1[i] = y; + } +} + +/// Obtains the remainder of dividing `a` with `2^{D-1}`. +/// +/// For every coefficient `c` of the polynomial a, computes `c0`, `c1` +/// such that `c mod Q = c1 * 2^D + c0`, with `-2^{D-1} < c0 <= 2^{D-1}`. +/// +/// # Arguments +/// +/// * `a` - a polynomial in standard representation (not NTT) +/// * `a0` - output polynomial representing the remainder (coefficients `c0`) +pub fn power2round_remainder(a: &Poly) -> Poly { + let mut remainder = [0; N]; + for i in 0..N { + let (x, _) = rounding::power2round(a[i]); + remainder[i] = x; + } + remainder +} + +/// Obtains the quotient of dividing `a` with `2^{D-1}`. +/// +/// For every coefficient `c` of the polynomial `a`, computes `c0, c1` +/// such that `c mod Q = c1 * 2^D + c0`, with `-2^{D-1} < c0 <= 2^{D-1}`. +/// +/// # Arguments +/// +/// * `a` - a polynomial in standard representation (not NTT) +/// * `a1` - output polynomial representing the quotient (coefficients `c1`) +pub fn power2round_quotient(a: &Poly) -> Poly { + let mut quotient = [0; N]; + for i in 0..N { + let (_, y) = rounding::power2round(a[i]); + quotient[i] = y; + } + quotient +} + +/// Obtains the high bits and the low bits of `a`. +/// +/// For every coefficient `c` of the input polynomial `a`, computes its +/// high bits `c1` and low bits `c0` such that `c mod Q = c1*ALPHA + c0`, +/// where -ALPHA/2 < c0 <= ALPHA/2. +/// Exception: if `c1 = (Q-1)/ALPHA`, `c1` is set to 0 and `c0 = c mod Q - Q`. +/// +/// # Arguments +/// +/// * `a` - a polynomial in standard representation (not NTT) +/// * `a0` - output polynomial representing `a`'s low bits (coefficients `c0`) +/// * `a1` - output polynomial representing `a`'s high bits (coefficients `c1`) +pub fn decompose(a: &Poly, a0: &mut Poly, a1: &mut Poly) { + for i in 0..N { + let (x, y) = rounding::decompose(a[i]); + a0[i] = x; // low bits + a1[i] = y; // high bits + } +} + +/// Returns a polynomial whose coefficients are the high bits of `a`. +/// +/// For every coefficient `c` of the input polynomial a, computes its +/// high bits `c1` and low bits `c0` such that `c mod Q = c1*ALPHA + c0`, +/// where `-ALPHA/2 < c0 <= ALPHA/2`. +/// Exception: if `c1 = (Q-1)/ALPHA`, `c1` is set to 0 and `c0 = c mod Q - Q`. +/// +/// # Arguments +/// +/// * `a` - a polynomial in standard representation (not NTT) +#[cfg(feature = "optimize_stack")] +pub fn high_bits(a: &Poly) -> Poly { + let mut high_bits: Poly = [0; N]; + for i in 0..N { + let (_x, y) = rounding::decompose(a[i]); + high_bits[i] = y; + } + return high_bits; +} + +/// Returns a polynomial whose coefficients are the low bits of `a`. +/// +/// For every coefficient `c` of the input polynomial `a`, computes its +/// high bits `c1` and low bits `c0` such that `c mod Q = c1*ALPHA + c0`, +/// where `-ALPHA/2 < c0 <= ALPHA/2`. +/// Exception: if `c1 = (Q-1)/ALPHA`, `c1` is set to 0 and `c0 = c mod Q - Q`. +/// +/// # Arguments +/// +/// * `a` - a polynomial in standard representation (not NTT) +#[cfg(feature = "optimize_stack")] +pub fn low_bits(a: &Poly) -> Poly { + let mut low_bits: Poly = [0; N]; + for i in 0..N { + let (x, _y) = rounding::decompose(a[i]); + low_bits[i] = x; + } + return low_bits; +} + +/// Makes the hint used to obtain `a` from an approximate result `b`. +/// +/// Given a polynomial of low bits `a`, and a polynomial of high bits `b`, +/// computes the hint polynomial `h`. The coefficient of `h` indicate +/// whether the low bits of the corresponding coefficient of the input +/// polynomial `a` overflow into the high bits (`b`). +/// +/// # Arguments +/// +/// * `a` - a polynomial +/// * `b` - a polynomial +/// * `h` - the output polynomial +pub fn make_hint(a: &Poly, b: &Poly, h: &mut Poly) -> usize { + let mut s = 0; + + for i in 0..N { + h[i] = rounding::make_hint(a[i], b[i]) as i32; + s += h[i] as usize; + } + + s +} + +/// Uses a hint polynomial `h` to correct the high bits of a polynomial `b`. +/// +/// # Arguments +/// +/// * `a` - the output corrected polynomial +/// * `b` - a polynomial +/// * `h` - the hint polynomial: containing values 0 or 1 +pub fn use_hint(a: &mut Poly, b: &Poly, h: &Poly) { + for i in 0..N { + a[i] = rounding::use_hint(b[i], h[i] as u32); + } +} + +/// Checks if the infinity norm of a polynomial `a` against a given bound `b`. +/// +/// The input coefficients must be reduced by `reduce32()`. +/// +/// # Arguments +/// +/// * `a` - a polynomial +/// * `b` - the bound. +pub fn chknorm(a: &Poly, b: i32) -> bool { + if b > (Q - 1) / 8 { + return true; + } + + // It is ok to leak which coefficient violates the bound since + // the probability for each coefficient is independent of secret + // data but we must not leak the sign of the centralized representative. + for i in 0..N { + let mut t: i32 = a[i] >> 31; + t = a[i] - (t & 2 * a[i]); + + if t >= b { + return true; + } + } + return false; +} + +/// Samples a polynomial with random coefficients in `[0, Q - 1]`. +/// +/// The sampling is done by performing rejection sampling on the output stream +/// of `SHAKE256(seed|nonce)`. +/// +/// # Arguments +/// +/// * `a` - the output polynomial +/// * `seed` - an array of random bytes +/// * `nonce` - a number. +pub fn uniform(a: &mut Poly, seed: &[u8; SEEDBYTES], nonce: u16) { + use digest::{ExtendableOutput, Input, XofReader}; + use sha3::Shake128; + + fn rej_uniform(a: &mut [i32], i_start: usize, buf: &[u8], buf_len: usize) -> usize { + let mut ctr = 0usize; + let mut pos = 0usize; + let mut t: u32; + + let len = a.len() - i_start; + + while ctr < len && pos + 3 <= buf_len { + t = buf[pos] as u32; + pos += 1; + t |= (buf[pos] as u32) << 8; + pos += 1; + t |= (buf[pos] as u32) << 16; + pos += 1; + t &= 0x7FFFFF; + if t < (Q as u32) { + a[i_start + ctr] = t as i32; + ctr += 1; + } + } + + ctr + } + + let mut hasher = Shake128::default(); + hasher.process(seed); + + let nonce0 = (nonce & ((1 << 8) - 1)) as u8; + let nonce1 = (nonce >> 8) as u8; + hasher.process(&[nonce0, nonce1]); + + const STREAM128_BLOCKBYTES: usize = 168; + const POLY_UNIFORM_NBLOCKS: usize = (768 + STREAM128_BLOCKBYTES - 1) / STREAM128_BLOCKBYTES; + let mut buf_len = POLY_UNIFORM_NBLOCKS * STREAM128_BLOCKBYTES; + let mut buf = [0u8; POLY_UNIFORM_NBLOCKS * STREAM128_BLOCKBYTES + 2]; + + let mut xof = hasher.xof_result(); + xof.read(&mut buf[..buf_len]); + + let mut ctr = rej_uniform(a, 0, &buf, buf_len); + + while ctr < N { + let off = buf_len % 3; + for i in 0..off { + buf[i] = buf[buf_len - off + i]; + } + for i in 0..STREAM128_BLOCKBYTES { + buf[off + i] = 0; + } + xof.read(&mut buf[off..off + STREAM128_BLOCKBYTES]); + + buf_len = STREAM128_BLOCKBYTES + off; + + ctr += rej_uniform(a, ctr, &buf, buf_len); + } +} + +/// Samples a polynomial with random coefficients in `[-ETA, ETA]`. +/// +/// The sampling is done by performing rejection sampling on the output stream +/// of `SHAKE256(seed|nonce)`. +/// +/// # Arguments +/// +/// * `a` - the output polynomial +/// * `seed` - an array of random bytes +/// * `nonce` - a number. +pub fn uniform_eta(a: &mut Poly, seed: &[u8; CRHBYTES], nonce: u16) { + use digest::{ExtendableOutput, Input, XofReader}; + use sha3::Shake256; + + const STREAM256_BLOCKBYTES: usize = 136; + + const POLY_UNIFORM_ETA_NBLOCKS: usize = match ETA { + 2 => (136 + STREAM256_BLOCKBYTES - 1) / STREAM256_BLOCKBYTES, + _ => (227 + STREAM256_BLOCKBYTES - 1) / STREAM256_BLOCKBYTES, + }; + + fn rej_eta(a: &mut [i32], a_start: usize, buf: &[u8], buf_len: usize) -> usize { + let mut ctr = 0; + let mut pos = 0; + + while a_start + ctr < a.len() && pos < buf_len { + let mut t0 = (buf[pos] as u32) & 0x0F; + let mut t1 = (buf[pos] as u32) >> 4; + pos += 1; + + if ETA == 2 { + if t0 < 15 { + t0 = t0 - (205 * t0 >> 10) * 5; + a[a_start + ctr] = 2 - (t0 as i32); + ctr += 1; + } + if t1 < 15 && a_start + ctr < a.len() { + t1 = t1 - (205 * t1 >> 10) * 5; + a[a_start + ctr] = 2 - (t1 as i32); + ctr += 1; + } + } else if ETA == 4 { + if t0 < 9 { + a[a_start + ctr] = 4 - (t0 as i32); + ctr += 1; + } + if t1 < 9 && a_start + ctr < a.len() { + a[a_start + ctr] = 4 - (t1 as i32); + ctr += 1; + } + } + } + + ctr + } + + let buf_len = POLY_UNIFORM_ETA_NBLOCKS * STREAM256_BLOCKBYTES; + let mut buf = [0u8; POLY_UNIFORM_ETA_NBLOCKS * STREAM256_BLOCKBYTES]; + + let mut hasher = Shake256::default(); + hasher.process(seed); + let nonce0 = (nonce & ((1 << 8) - 1)) as u8; + let nonce1 = (nonce >> 8) as u8; + hasher.process(&[nonce0, nonce1]); + let mut xof = hasher.xof_result(); + xof.read(&mut buf[..buf_len]); + + let mut ctr = rej_eta(a, 0, &buf, buf_len); + + while ctr < N { + xof.read(&mut buf[..STREAM256_BLOCKBYTES]); + ctr += rej_eta(a, ctr, &buf, STREAM256_BLOCKBYTES); + } +} + +/// Samples a polynomial with random coefficients in `[-(GAMMA1 - 1), GAMMA1]`. +/// +/// The sampling is done by unpacking the first `POLZ_SIZE_PACKED` bytes in the +/// output stream of `SHAKE256(seed|nonce)`. +/// +/// # Arguments +/// +/// * `a` - the output polynomial +/// * `seed` - an array of random bytes +/// * `nonce` - a number. +pub fn uniform_gamma1m1(a: &mut Poly, seed: &[u8; CRHBYTES], nonce: u16) { + use digest::{ExtendableOutput, Input, XofReader}; + use sha3::Shake256; + const SHAKE256_RATE: usize = 136; + + let mut outbuf = [0; 5 * SHAKE256_RATE]; + let mut nonce_bytes = [0; 2]; + LittleEndian::write_u16(&mut nonce_bytes, nonce); + + let mut hasher = Shake256::default(); + hasher.process(seed); + hasher.process(&nonce_bytes); + + let mut xof = hasher.xof_result(); + xof.read(&mut outbuf); + + z_unpack(a, array_ref!(&outbuf, 0, POLZ_SIZE_PACKED)); +} + +/// Returns a polynomial with coefficients in {0, -1, 1}. +/// +/// Returns a polynomial sampled with `TAU` nonzero coefficients in +/// {-1, 1} and `N - TAU` zero coefficients using the output stream +/// of `SHAKE256(seed)`. +/// More details can be found in the paper, in section 2.3. +/// +/// +/// # Arguments +/// +/// * `seed` - an array of bytes +pub fn build_challenge_from_seed(seed: &[u8; SEEDBYTES]) -> Poly { + use digest::{ExtendableOutput, Input, XofReader}; + use sha3::Shake256; + const SHAKE256_RATE: usize = 136; + + let mut outbuf = [0u8; SHAKE256_RATE]; + + let mut hasher = Shake256::default(); + hasher.process(seed); + let mut xof = hasher.xof_result(); + xof.read(&mut outbuf); + + let mut signs: u64 = 0; + for i in 0..8 { + signs |= (outbuf[i] as u64) << 8 * i; + } + + let mut pos = 8; + let mut c = [0i32; N]; + for i in (N - TAU)..N { + let b = loop { + if pos >= SHAKE256_RATE { + xof.read(&mut outbuf); + pos = 0; + } + + let b = outbuf[pos] as usize; + pos += 1; + if b <= i { + break b; + } + }; + + c[i] = c[b]; + c[b] = 1i32 - (2 * (signs & 1) as i32); + signs >>= 1; + } + + c +} + +/// Bit-packs a polynomial with coefficients in `[-ETA, ETA]`. +/// +/// # Arguments +/// +/// * `r` - the output array, which will contain the polynomial's encoding +/// * `a` - the polynomial to encode +#[inline] +pub fn eta_pack(r: &mut [u8; POLETA_SIZE_PACKED], a: &Poly) { + if ETA == 2 { + let mut t = [0u8; 8]; + for i in 0..(N / 8) { + for j in 0..8 { + t[j] = (ETA - a[8 * i + j]) as u8; + } + + r[3 * i + 0] = (t[0] >> 0) | (t[1] << 3) | (t[2] << 6); + r[3 * i + 1] = (t[2] >> 2) | (t[3] << 1) | (t[4] << 4) | (t[5] << 7); + r[3 * i + 2] = (t[5] >> 1) | (t[6] << 2) | (t[7] << 5); + } + } else { + let mut t = [0u8; 2]; + for i in 0..(N / 2) { + t[0] = (ETA - a[2 * i + 0]) as u8; + t[1] = (ETA - a[2 * i + 1]) as u8; + r[i] = t[0] | (t[1] << 4); + } + } +} + +/// Unpacks a polynomial with coefficients in `[-ETA, ETA]`. +/// +/// # Arguments +/// +/// * `r` - the output decoded polynomial +/// * `a` - the polynomial's encoding +#[inline] +pub fn eta_unpack(r: &mut Poly, a: &[u8; POLETA_SIZE_PACKED]) { + if ETA == 2 { + for i in 0..(N / 8) { + r[8 * i + 0] = ((a[3 * i + 0] as i32) >> 0) & 7; + r[8 * i + 1] = ((a[3 * i + 0] as i32) >> 3) & 7; + r[8 * i + 2] = (((a[3 * i + 0] as i32) >> 6) | ((a[3 * i + 1] as i32) << 2)) & 7; + r[8 * i + 3] = ((a[3 * i + 1] as i32) >> 1) & 7; + r[8 * i + 4] = ((a[3 * i + 1] as i32) >> 4) & 7; + r[8 * i + 5] = (((a[3 * i + 1] as i32) >> 7) | ((a[3 * i + 2] as i32) << 1)) & 7; + r[8 * i + 6] = ((a[3 * i + 2] as i32) >> 2) & 7; + r[8 * i + 7] = ((a[3 * i + 2] as i32) >> 5) & 7; + + for j in 0..8 { + r[8 * i + j] = ETA - r[8 * i + j]; + } + } + } else { + for i in 0..(N / 2) { + r[2 * i + 0] = (a[i] as i32) & 0x0F; + r[2 * i + 1] = (a[i] as i32) >> 4; + r[2 * i + 0] = ETA - r[2 * i + 0]; + r[2 * i + 1] = ETA - r[2 * i + 1]; + } + } +} + +/// Bit-packs a polynomial with coefficients fitting in 10 bits. +/// +/// # Arguments +/// +/// * `r` - the output array, which will contain the polynomial's encoding +/// * `a` - the polynomial to encode +#[inline] +pub fn t1_pack(r: &mut [u8; POLT1_SIZE_PACKED], a: &Poly) { + for i in 0..(N / 4) { + r[5 * i + 0] = (a[4 * i + 0] >> 0) as u8; + r[5 * i + 1] = ((a[4 * i + 0] >> 8) | (a[4 * i + 1] << 2)) as u8; + r[5 * i + 2] = ((a[4 * i + 1] >> 6) | (a[4 * i + 2] << 4)) as u8; + r[5 * i + 3] = ((a[4 * i + 2] >> 4) | (a[4 * i + 3] << 6)) as u8; + r[5 * i + 4] = (a[4 * i + 3] >> 2) as u8; + } +} + +/// Unpacks a polynomial with coefficients fitting in 10 bits. +/// +/// # Arguments +/// +/// * `r` - the output decoded polynomial +/// * `a` - the polynomial's encoding +#[inline] +pub fn t1_unpack(r: &mut Poly, a: &[u8; POLT1_SIZE_PACKED]) { + for i in 0..(N / 4) { + r[4 * i + 0] = + ((((a[5 * i + 0] >> 0) as u32) | ((a[5 * i + 1] as u32) << 8)) & 0x3FF) as i32; + r[4 * i + 1] = + ((((a[5 * i + 1] >> 2) as u32) | ((a[5 * i + 2] as u32) << 6)) & 0x3FF) as i32; + r[4 * i + 2] = + ((((a[5 * i + 2] >> 4) as u32) | ((a[5 * i + 3] as u32) << 4)) & 0x3FF) as i32; + r[4 * i + 3] = + ((((a[5 * i + 3] >> 6) as u32) | ((a[5 * i + 4] as u32) << 2)) & 0x3FF) as i32; + } +} + +/// Packs a polynomial with coefficients in `[-(GAMMA1 - 1), GAMMA1]`. +/// +/// # Arguments +/// +/// * `r` - the output array, which will contain the polynomial's encoding +/// * `a` - the polynomial to encode +#[inline] +pub fn z_pack(r: &mut [u8; POLZ_SIZE_PACKED], a: &Poly) { + let mut t = [0u32; 4]; + + if GAMMA1 == (1 << 17) { + for i in 0..(N / 4) { + for j in 0..4 { + t[j] = (GAMMA1 - a[4 * i + j]) as u32; + } + + r[9 * i + 0] = t[0] as u8; + r[9 * i + 1] = (t[0] >> 8) as u8; + r[9 * i + 2] = (t[0] >> 16) as u8; + r[9 * i + 2] |= (t[1] << 2) as u8; + r[9 * i + 3] = (t[1] >> 6) as u8; + r[9 * i + 4] = (t[1] >> 14) as u8; + r[9 * i + 4] |= (t[2] << 4) as u8; + r[9 * i + 5] = (t[2] >> 4) as u8; + r[9 * i + 6] = (t[2] >> 12) as u8; + r[9 * i + 6] |= (t[3] << 6) as u8; + r[9 * i + 7] = (t[3] >> 2) as u8; + r[9 * i + 8] = (t[3] >> 10) as u8; + } + } else if GAMMA1 == (1 << 19) { + for i in 0..(N / 2) { + t[0] = (GAMMA1 - a[2 * i + 0]) as u32; + t[1] = (GAMMA1 - a[2 * i + 1]) as u32; + + r[5 * i + 0] = t[0] as u8; + r[5 * i + 1] = (t[0] >> 8) as u8; + r[5 * i + 2] = (t[0] >> 16) as u8; + r[5 * i + 2] |= (t[1] << 4) as u8; + r[5 * i + 3] = (t[1] >> 4) as u8; + r[5 * i + 4] = (t[1] >> 12) as u8; + } + } +} + +/// Unpacks a polynomial with coefficients in `[-(GAMMA1 - 1), GAMMA1]`. +/// +/// # Arguments +/// +/// * `r` - the output decoded polynomial +/// * `a` - the polynomial's encoding +#[inline] +pub fn z_unpack(r: &mut Poly, a: &[u8; POLZ_SIZE_PACKED]) { + if GAMMA1 == (1 << 17) { + for i in 0..(N / 4) { + r[4 * i + 0] = a[9 * i + 0] as i32; + r[4 * i + 0] |= (a[9 * i + 1] as i32) << 8; + r[4 * i + 0] |= (a[9 * i + 2] as i32) << 16; + r[4 * i + 0] &= 0x3FFFF; + + r[4 * i + 1] = (a[9 * i + 2] >> 2) as i32; + r[4 * i + 1] |= (a[9 * i + 3] as i32) << 6; + r[4 * i + 1] |= (a[9 * i + 4] as i32) << 14; + r[4 * i + 1] &= 0x3FFFF; + + r[4 * i + 2] = (a[9 * i + 4] >> 4) as i32; + r[4 * i + 2] |= (a[9 * i + 5] as i32) << 4; + r[4 * i + 2] |= (a[9 * i + 6] as i32) << 12; + r[4 * i + 2] &= 0x3FFFF; + + r[4 * i + 3] = (a[9 * i + 6] >> 6) as i32; + r[4 * i + 3] |= (a[9 * i + 7] as i32) << 2; + r[4 * i + 3] |= (a[9 * i + 8] as i32) << 10; + r[4 * i + 3] &= 0x3FFFF; + + for j in 0..4 { + r[4 * i + j] = GAMMA1 - r[4 * i + j]; + } + } + } else if GAMMA1 == (1 << 19) { + for i in 0..(N / 2) { + r[2 * i + 0] = a[5 * i + 0] as i32; + r[2 * i + 0] |= (a[5 * i + 1] as i32) << 8; + r[2 * i + 0] |= (a[5 * i + 2] as i32) << 16; + r[2 * i + 0] &= 0xFFFFF; + + r[2 * i + 1] = (a[5 * i + 2] >> 4) as i32; + r[2 * i + 1] |= (a[5 * i + 3] as i32) << 4; + r[2 * i + 1] |= (a[5 * i + 4] as i32) << 12; + r[2 * i + 0] &= 0xFFFFF; + + r[2 * i + 0] = GAMMA1 - r[2 * i + 0]; + r[2 * i + 1] = GAMMA1 - r[2 * i + 1]; + } + } +} + +/// Bit-packs a polynomial with coefficients in `[0,15]` or `[0,43]`. +/// +/// # Arguments +/// +/// * `r` - the output array, which will contain the polynomial's encoding +/// * `a` - the polynomial to encode +#[inline] +pub fn w1_pack(r: &mut [u8; POLW1_SIZE_PACKED], a: &Poly) { + if GAMMA2 == (Q - 1) / 88 { + for i in 0..(N / 4) { + r[3 * i + 0] = a[4 * i + 0] as u8; + r[3 * i + 0] |= (a[4 * i + 1] << 6) as u8; + r[3 * i + 1] = (a[4 * i + 1] >> 2) as u8; + r[3 * i + 1] |= (a[4 * i + 2] << 4) as u8; + r[3 * i + 2] = (a[4 * i + 2] >> 4) as u8; + r[3 * i + 2] |= (a[4 * i + 3] << 2) as u8; + } + } else if GAMMA2 == (Q - 1) / 32 { + for i in 0..(N / 2) { + r[i] = (a[2 * i + 0] | (a[2 * i + 1] << 4)) as u8; + } + } +} + +/// Bit-packs a polynomial `t0` with coefficients in `[-2^{D-1}, 2^{D-1}]`. +/// +/// # Arguments +/// +/// * `r` - the output array, which will contain the polynomial's encoding +/// * `a` - the polynomial to encode +#[inline] +pub fn t0_pack(r: &mut [u8], a: &Poly) { + let mut t = [0u32; 8]; + for i in 0..(N / 8) { + for j in 0..8 { + t[j] = ((1 << (D - 1) as u32) - a[8 * i + j]) as u32; + } + + r[13 * i + 0] = (t[0]) as u8; + r[13 * i + 1] = (t[0] >> 8) as u8; + r[13 * i + 1] |= (t[1] << 5) as u8; + r[13 * i + 2] = (t[1] >> 3) as u8; + r[13 * i + 3] = (t[1] >> 11) as u8; + r[13 * i + 3] |= (t[2] << 2) as u8; + r[13 * i + 4] = (t[2] >> 6) as u8; + r[13 * i + 4] |= (t[3] << 7) as u8; + r[13 * i + 5] = (t[3] >> 1) as u8; + r[13 * i + 6] = (t[3] >> 9) as u8; + r[13 * i + 6] |= (t[4] << 4) as u8; + r[13 * i + 7] = (t[4] >> 4) as u8; + r[13 * i + 8] = (t[4] >> 12) as u8; + r[13 * i + 8] |= (t[5] << 1) as u8; + r[13 * i + 9] = (t[5] >> 7) as u8; + r[13 * i + 9] |= (t[6] << 6) as u8; + r[13 * i + 10] = (t[6] >> 2) as u8; + r[13 * i + 11] = (t[6] >> 10) as u8; + r[13 * i + 11] |= (t[7] << 3) as u8; + r[13 * i + 12] = (t[7] >> 5) as u8; + } +} diff --git a/third_party/dilithium/src/polyvec.rs b/third_party/dilithium/src/polyvec.rs new file mode 100644 index 0000000..cbc3f40 --- /dev/null +++ b/third_party/dilithium/src/polyvec.rs @@ -0,0 +1,167 @@ +#![allow(dead_code)] + +use params::{K, L, N}; +use poly::{self, Poly}; + +macro_rules! polyvec { + ( $polyvec:ident, $len:expr ) => { + #[derive(Copy, Clone)] + pub struct $polyvec(pub [Poly; $len]); + + impl $polyvec { + pub fn reduce(&mut self) { + self.0.iter_mut().for_each(poly::reduce) + } + + pub fn caddq(&mut self) { + self.0.iter_mut().for_each(poly::caddq) + } + + pub fn freeze(&mut self) { + self.0.iter_mut().for_each(poly::freeze) + } + + pub fn with_add(&mut self, u: &Self, v: &Self) { + for i in 0..$len { + poly::add(&mut self[i], &u[i], &v[i]); + } + } + + pub fn add_assign(&mut self, u: &Self) { + for i in 0..$len { + poly::add_assign(&mut self[i], &u[i]); + } + } + + pub fn with_sub(&mut self, u: &Self, v: &Self) { + for i in 0..$len { + poly::sub(&mut self[i], &u[i], &v[i]); + } + } + + pub fn shift_left(&mut self) { + self.0.iter_mut().for_each(|p| poly::shift_left(p)); + } + + pub fn ntt(&mut self) { + self.0.iter_mut().for_each(poly::ntt); + } + + pub fn invntt_montgomery(&mut self) { + self.0.iter_mut().for_each(poly::invntt_montgomery) + } + + pub fn chknorm(&self, bound: i32) -> bool { + self.0 + .iter() + .map(|p| poly::chknorm(p, bound)) + .fold(false, |x, y| x | y) + } + } + + impl ::core::ops::Index for $polyvec { + type Output = Poly; + + #[inline(always)] + fn index(&self, i: usize) -> &Self::Output { + self.0.index(i) + } + } + + impl ::core::ops::IndexMut for $polyvec { + #[inline(always)] + fn index_mut(&mut self, i: usize) -> &mut Self::Output { + self.0.index_mut(i) + } + } + + impl ::core::cmp::PartialEq for $polyvec { + fn eq(&self, other: &Self) -> bool { + self.0 + .iter() + .zip(&other.0) + .flat_map(|(x, y)| x.iter().zip(y.iter())) + .all(|(x, y)| x == y) + } + } + + impl Eq for $polyvec {} + + impl Default for $polyvec { + fn default() -> Self { + $polyvec([[0; N]; $len]) + } + } + }; +} + +polyvec!(PolyVecL, L); +polyvec!(PolyVecK, K); + +pub fn pointwise_acc_invmontgomery(w: &mut Poly, u: &PolyVecL, v: &PolyVecL) { + let mut t = [0; N]; + + poly::pointwise_invmontgomery(w, &u[0], &v[0]); + + for i in 1..L { + poly::pointwise_invmontgomery(&mut t, &u[i], &v[i]); + poly::add_assign(w, &t); + } +} + +/// Computes a partial result of the dot product `w = u * v`. +/// +/// # Arguments +/// * `w` - the output polynomial, which will contain the partial result +/// * `u_component` - the polynomial `u[i]` +/// * `v_component` - the polynomial `v[i]` +/// * `i` - the index +pub fn pointwise_acc_invmontgomery_componentwise( + w: &mut Poly, + u_component: &Poly, + v_component: &Poly, + i: usize, +) { + if i == 0 { + poly::pointwise_invmontgomery(w, &u_component, &v_component); + return; + } + + let mut t = [0; N]; + poly::pointwise_invmontgomery(&mut t, &u_component, &v_component); + poly::add_assign(w, &t); +} + +impl PolyVecK { + pub fn power2round(&self, v0: &mut Self, v1: &mut Self) { + for i in 0..K { + poly::power2round(&self[i], &mut v0[i], &mut v1[i]); + } + } + + pub fn power2round_remainder(&self, v0: &mut Self) { + for i in 0..K { + v0[i] = poly::power2round_remainder(&self[i]); + } + } + + pub fn decompose(&self, v0: &mut Self, v1: &mut Self) { + for i in 0..K { + poly::decompose(&self[i], &mut v0[i], &mut v1[i]); + } + } +} + +pub fn make_hint(u: &PolyVecK, v: &PolyVecK, h: &mut PolyVecK) -> usize { + let mut s = 0; + for i in 0..K { + s += poly::make_hint(&u[i], &v[i], &mut h[i]); + } + s +} + +pub fn use_hint(w: &mut PolyVecK, u: &PolyVecK, h: &PolyVecK) { + for i in 0..K { + poly::use_hint(&mut w[i], &u[i], &h[i]); + } +} diff --git a/third_party/dilithium/src/reduce.rs b/third_party/dilithium/src/reduce.rs new file mode 100644 index 0000000..54a1f03 --- /dev/null +++ b/third_party/dilithium/src/reduce.rs @@ -0,0 +1,52 @@ +use params::{Q, QINV}; + +/// Returns a value between `-Q` and `Q` that is equivalent to `a`. +/// +/// For a finite field element `a` with `-2^{31}*Q <= a <= Q*2^31`, +/// computes `r` equivalent to `a*2^{-32} (mod Q)` such that `-Q < r < Q`. +/// +/// # Arguments +/// +/// * `a` - a number between `2^{31}*Q` and `Q*2^31`. +pub fn montgomery_reduce(a: i64) -> i32 { + let mut t: i32 = (((a as i32) as i64) * (QINV as i64)) as i32; + t = ((a - (t as i64) * (Q as i64)) >> 32) as i32; + t +} + +/// Returns a value between `-6283009` and `6283007` that is equivalent to `a`. +/// +/// For a finite field element `a` with `a <= 2^{31} - 2^{22} - 1`, +/// computes `r` equivalent to `a (mod Q)` such that +/// `-6283009 <= r <= 6283007`. +/// +/// # Arguments +/// +/// * `a` - a number between `2^{31}*Q` and `Q*2^31`. +pub fn reduce32(a: i32) -> i32 { + let mut t: i32 = (a + (1 << 22)) >> 23; + t = a - t * Q; + t +} + +/// Adds `Q` if the input finite field element is negative. +/// +/// # Arguments +/// +/// * `a` - a number. +pub fn caddq(a: i32) -> i32 { + let mut t = a; + t += (a >> 31) & Q; + t +} + +/// Computes the standard representative `r = a mod Q`. +/// +/// # Arguments +/// +/// * `a` - a number. +pub fn freeze(a: i32) -> i32 { + let a = reduce32(a); + let a = caddq(a); + a +} diff --git a/third_party/dilithium/src/rounding.rs b/third_party/dilithium/src/rounding.rs new file mode 100644 index 0000000..6e8e8ac --- /dev/null +++ b/third_party/dilithium/src/rounding.rs @@ -0,0 +1,93 @@ +use params::{D, GAMMA2, Q}; + +/// Returns the remainder and the quotient of `a` divided by `2^{D-1}`. +/// +/// For a finite field element `a`, computes `a0` and `a1` such that +/// `a mod Q = a1*2^D + a0` with `-2^{D-1} < a0 <= 2^{D-1}`. +/// +/// # Arguments +/// +/// * `a` - a number assumed to be a standard representative modulo `Q`. +pub fn power2round(a: i32) -> (i32, i32) { + let a1: i32 = (a + (1 << (D - 1)) - 1) >> D; + let a0: i32 = a - (a1 << D); + + (a0, a1) +} + +/// Computes the high bits and low bits of `a`. +/// +/// For a finite field element `a`, computes the high and the low bits `a1` +/// and respectively `a0`, such that `a mod Q = a1*ALPHA + a0` +/// with `-ALPHA/2 < a0 <= ALPHA/2`. +/// Exception: If `a1 = (Q-1)/ALPHA`, `a0` is set to 0. +/// +/// # Arguments +/// +/// * `a` - a number assumed to be a standard representative modulo `Q`. +pub fn decompose(a: i32) -> (i32, i32) { + let mut a1: i32 = (a + 127) >> 7; + if GAMMA2 == (Q - 1) / 32 { + a1 = (a1 * 1025 + (1 << 21)) >> 22; + a1 &= 15; + } else if GAMMA2 == (Q - 1) / 88 { + a1 = (a1 * 11275 + (1 << 23)) >> 24; + a1 ^= ((43 - a1) >> 31) & a1; + } + + let mut a0: i32 = a - a1 * 2 * GAMMA2; + a0 -= (((Q - 1) / 2 - a0) >> 31) & Q; + + (a0, a1) +} + +/// Computes the hint bit. +/// +/// The hint bit indicates whether the low bits `a0` overflow into the +/// the high bits `a1`. +/// +/// # Arguments +/// +/// * `a0` - a number representing the low bits of some element `a` +/// * `a1` - a number representing the high bits of the same element `a` +pub fn make_hint(a0: i32, a1: i32) -> u32 { + if a0 > GAMMA2 || a0 < -GAMMA2 || (a0 == -GAMMA2 && a1 != 0) { + 1 + } else { + 0 + } +} + +/// Uses the given hint to correct the high bits of a. +/// +/// # Arguments +/// +/// * `a` - the number to be corrected +/// * `hint` - a value 0 or 1 +pub fn use_hint(a: i32, hint: u32) -> i32 { + let (a0, a1) = decompose(a); + + if hint == 0 { + a1 + } else if GAMMA2 == (Q - 1) / 32 { + if a0 > 0 { + (a1 + 1) & 15 + } else { + (a1 - 1) & 15 + } + } else { + if a0 > 0 { + if a1 == 43 { + 0 + } else { + a1 + 1 + } + } else { + if a1 == 0 { + 43 + } else { + a1 - 1 + } + } + } +} diff --git a/third_party/dilithium/src/sign.rs b/third_party/dilithium/src/sign.rs new file mode 100644 index 0000000..fca49c1 --- /dev/null +++ b/third_party/dilithium/src/sign.rs @@ -0,0 +1,1220 @@ +// TODO(dianamin): Try moving Polys on the heap using boxing. +// TODO(dianamin): Remove ": Poly" where it is not necessary. +// TODO(dianamin): Add a function that replaces let x: Poly = [0; N] + +use packing; +use params::{ + BETA, CRHBYTES, GAMMA1, GAMMA2, K, L, N, OMEGA, PK_SIZE_PACKED, POLETA_SIZE_PACKED, + POLT0_SIZE_PACKED, POLT1_SIZE_PACKED, POLW1_SIZE_PACKED, SEEDBYTES, SIG_SIZE_PACKED, + SK_SIZE_PACKED, SK_SIZE_PACKED_ORIGINAL, +}; +use poly::{self, Poly}; +use polyvec::{self, PolyVecK, PolyVecL}; + +use digest::{ExtendableOutput, Input, XofReader}; +use sha3::Shake256; + +/// Helper function used both when signing and verifying. +/// +/// Expands `A[i][j]` from the randomness seed `rho`. +/// +/// # Arguments +/// +/// * `rho` - an array of random bytes +/// * `i` - the index of the row +/// * `j` - the index of the column +/// * `mat_component` - the output polynomial representing `A[i][j]` +fn expand_mat_component(rho: &[u8; SEEDBYTES], i: usize, j: usize, mat_component: &mut Poly) { + poly::uniform(mat_component, rho, ((i << 8) + j) as u16); +} + +/// Helper function used when signing in optimized speed mode. +/// +/// Expands the matrix `A` from the randomness seed `rho`. +/// +/// # Arguments +/// +/// * `rho` - an array of random bytes +/// * `mat` - a matrix of polynomials of `K` rows and `L` columns. +#[cfg(not(feature = "optimize_stack"))] +fn expand_mat(rho: &[u8; SEEDBYTES], mat: &mut [PolyVecL; K]) { + for i in 0..K { + for j in 0..L { + expand_mat_component(rho, i, j, &mut mat[i][j]); + } + } +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct SecKey { + rho: [u8; SEEDBYTES], + key: [u8; SEEDBYTES], + tr: [u8; SEEDBYTES], + s1_packed: [[u8; POLETA_SIZE_PACKED]; L], + s2_packed: [[u8; POLETA_SIZE_PACKED]; K], +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct PubKey { + pub rho: [u8; SEEDBYTES], + pub t1_packed: [[u8; POLT1_SIZE_PACKED]; K], +} + +impl Default for SecKey { + fn default() -> SecKey { + SecKey { + rho: [0; SEEDBYTES], + key: [0; SEEDBYTES], + tr: [0; SEEDBYTES], + s1_packed: [[0; POLETA_SIZE_PACKED]; L], + s2_packed: [[0; POLETA_SIZE_PACKED]; K], + } + } +} + +impl SecKey { + /// Encodes the secret key to an array of bytes. + /// + /// Fills the bytes array as follows: + /// `rho || key || tr || encodings of s1 || encodings of s2` + /// + /// # Arguments + /// + /// * `bytes` - an array of bytes where the encoding will be stored. + pub fn to_bytes(&self, bytes: &mut [u8; SK_SIZE_PACKED]) { + let mut offset = 0; + let mut push = |data: &[u8]| { + bytes[offset..][..data.len()].copy_from_slice(data); + offset += data.len(); + }; + + push(&self.rho); + push(&self.key); + push(&self.tr); + for i in 0..L { + push(&self.s1_packed[i]); + } + for i in 0..K { + push(&self.s2_packed[i]); + } + } + + /// Encodes the secret key to an array of bytes that includes `t0`. + /// + /// Fills the bytes array as follows: + /// `rho || key || tr || encodings of s1 || encodings of s2 || + /// encodings of t0` + /// + /// # Arguments + /// + /// * `bytes` - an array of bytes where the encoding will be stored. + pub fn to_bytes_original(&self, bytes: &mut [u8; SK_SIZE_PACKED_ORIGINAL]) { + self.to_bytes(array_mut_ref!(bytes, 0, SK_SIZE_PACKED)); + + let mut offset = SK_SIZE_PACKED; + let mut push = |data: &[u8]| { + bytes[offset..][..data.len()].copy_from_slice(data); + offset += data.len(); + }; + + #[cfg(feature = "optimize_stack")] + { + for i in 0..K { + let t0_component = poly::power2round_remainder(&self.compute_t_component(i)); + + let mut t0_bytes = [0u8; POLT0_SIZE_PACKED]; + poly::t0_pack(&mut t0_bytes, &t0_component); + push(&t0_bytes); + } + } + #[cfg(not(feature = "optimize_stack"))] + { + let mut mat = [PolyVecL::default(); K]; + expand_mat(&self.rho, &mut mat); + let mut s1 = self.compute_s1(); + s1.ntt(); + let s2 = self.compute_s2(); + + for i in 0..K { + let t0_component = + poly::power2round_remainder(&self.compute_t_component(&mat, &s1, &s2, i)); + + let mut t0_bytes = [0u8; POLT0_SIZE_PACKED]; + poly::t0_pack(&mut t0_bytes, &t0_component); + push(&t0_bytes); + } + } + } + + /// Decodes the secret key from an array of bytes. + /// + /// Extracts the fields from an array with the following shape: + /// `rho || key || tr || encodings of s1 || encodings of s2` + /// + /// # Arguments + /// + /// * `bytes` - an array of byres representing the secret key's encoding. + pub fn from_bytes(bytes: &[u8; SK_SIZE_PACKED]) -> SecKey { + let mut offset = 0; + let mut pull = |data: &mut [u8]| { + data.copy_from_slice(&bytes[offset..][..data.len()]); + offset += data.len(); + }; + + let mut sk = SecKey::default(); + + pull(&mut sk.rho); + pull(&mut sk.key); + pull(&mut sk.tr); + + for i in 0..L { + pull(&mut sk.s1_packed[i]); + } + for i in 0..K { + pull(&mut sk.s2_packed[i]); + } + + sk + } + + /// Decodes the secret key from an array of bytes that includes `t0`. + /// + /// Extracts the fields from an array with the following shape: + /// `rho || key || tr || encodings of s1 || encodings of s2 || encodings of t0`, + /// which is the original shape of the secret key in Dilithium. + /// In our implementation, the encodings of `t0` are removed. + /// + /// # Arguments + /// + /// * `bytes` - an array of byres representing the secret key's encoding. + pub fn from_bytes_original(bytes: &[u8; SK_SIZE_PACKED_ORIGINAL]) -> SecKey { + Self::from_bytes(array_ref!(&bytes, 0, SK_SIZE_PACKED)) + } + + /// Returns the public key. + pub fn genpk(&self) -> PubKey { + let mut pk = PubKey::default(); + pk.rho = self.rho.clone(); + + // Compute t = A * s1 + s2 + // And extract t1: the quotient of t / 2^D + + #[cfg(feature = "optimize_stack")] + { + for i in 0..K { + let t1_component = poly::power2round_quotient(&self.compute_t_component(i)); + poly::t1_pack(&mut pk.t1_packed[i], &t1_component); + } + } + + #[cfg(not(feature = "optimize_stack"))] + { + let mut mat = [PolyVecL::default(); K]; + expand_mat(&self.rho, &mut mat); + + let mut s1 = self.compute_s1(); + s1.ntt(); + let s2 = self.compute_s2(); + for i in 0..K { + let t1_component = + poly::power2round_quotient(&self.compute_t_component(&mat, &s1, &s2, i)); + poly::t1_pack(&mut pk.t1_packed[i], &t1_component); + } + } + + pk + } + + /// Generates a new secret key. + /// + /// # Arguments + /// + /// * `rng` - random number generator. + pub fn gensk(rng: &mut impl rng256::Rng256) -> Self { + let (sk, _) = Self::gensk_with_pk(rng); + sk + } + + /// Generates a new secret key and a new public key. + /// + /// # Arguments + /// + /// * `rng` - random number generator. + pub fn gensk_with_pk(rng: &mut impl rng256::Rng256) -> (Self, PubKey) { + let mut seed = [0u8; SEEDBYTES]; + rng.fill_bytes(&mut seed); + Self::gensk_with_pk_from_seed(&seed) + } + + /// Generates a new secret key from a given random seed. + /// + /// # Arguments + /// + /// * `seedbuff` - a random seed. + pub fn gensk_from_seed(seed: &[u8; SEEDBYTES]) -> Self { + let (sk, _) = Self::gensk_with_pk_from_seed(&seed); + sk + } + + /// Generates a new secret key and public key from a given random seed. + /// + /// # Arguments + /// + /// * `seedbuff` - a random seed. + pub fn gensk_with_pk_from_seed(seed: &[u8; SEEDBYTES]) -> (Self, PubKey) { + let mut sk = SecKey::default(); + let mut pk = PubKey::default(); + + // Expand 32 bytes of randomness into rho, rhoprime and key. + let mut seedbuf = [0u8; 2 * SEEDBYTES + CRHBYTES]; + seedbuf[..SEEDBYTES].copy_from_slice(seed); + shake256!(&mut seedbuf; &seedbuf[..SEEDBYTES]); + sk.rho.clone_from(array_ref!(seedbuf, 0, SEEDBYTES)); + sk.key + .clone_from(array_ref!(seedbuf, SEEDBYTES + CRHBYTES, SEEDBYTES)); + let rhoprime = array_ref!(seedbuf, SEEDBYTES, CRHBYTES); + let mut nonce = 0; + + pk.rho = sk.rho; + + // In the optimized stack mode, we store as few variables as possible. + // Because of that, some of the variables will be recomputed. + #[cfg(feature = "optimize_stack")] + { + // Expand the short vector s1 from rhoprime and store the encoding + // of each s1[i] in the secret key. + for i in 0..L { + let mut s1_component: Poly = [0; N]; + poly::uniform_eta(&mut s1_component, rhoprime, nonce); + poly::eta_pack(&mut sk.s1_packed[i], &s1_component); + nonce += 1; + } + + // Expand the short vector s2 from rhoprime and store the encoding + // of each s2[i] in the secret key. + for i in 0..K { + let mut s2_component: Poly = [0; N]; + poly::uniform_eta(&mut s2_component, rhoprime, nonce); + poly::eta_pack(&mut sk.s2_packed[i], &s2_component); + nonce += 1; + } + + // Computes t1: the quotient of t (= A * s1 + s2) / 2^D. + for i in 0..K { + let t1_component = poly::power2round_quotient(&sk.compute_t_component(i)); + poly::t1_pack(&mut pk.t1_packed[i], &t1_component); + } + } + + // In the optimized speed mode, the variables are computed and stored. + #[cfg(not(feature = "optimize_stack"))] + { + // Expand the short vector s1 from rhoprime and store the encoding + // of each s1[i] in the secret key. + let mut s1 = PolyVecL::default(); + for i in 0..L { + poly::uniform_eta(&mut s1[i], rhoprime, nonce); + poly::eta_pack(&mut sk.s1_packed[i], &s1[i]); + nonce += 1; + } + + // Expand the short vector s2 from rhoprime and store the encoding + // of each s2[i] in the secret key. + let mut s2 = PolyVecK::default(); + for i in 0..K { + poly::uniform_eta(&mut s2[i], rhoprime, nonce); + poly::eta_pack(&mut sk.s2_packed[i], &s2[i]); + nonce += 1; + } + + // Computes t1: the quotient of t (= A * s1 + s2) / 2^D. + let mut mat = [PolyVecL::default(); K]; + expand_mat(&sk.rho, &mut mat); + s1.ntt(); + for i in 0..K { + let t1_component = + poly::power2round_quotient(&sk.compute_t_component(&mat, &s1, &s2, i)); + poly::t1_pack(&mut pk.t1_packed[i], &t1_component); + } + } + + // Compute tr = CRH(rho || encodings of t1) + let mut hasher = Shake256::default(); + hasher.process(&sk.rho); + for i in 0..K { + hasher.process(&pk.t1_packed[i]); + } + + let mut xof = hasher.xof_result(); + xof.read(&mut sk.tr); + + (sk, pk) + } + + /// Returns a random polynomial `y[i]`. + /// + /// Computes the `i`-th component of `y`, where: + /// - `y` is a vector of polynomials 'sampled' when signing using + /// `rhoprime` (based on`key`, `mu`, `nonce`) + /// + /// # Arguments + /// + /// * `rhoprime` - an array of bytes obrained as `SHA256(key || mu)` + /// * `nonce` - current count of the attempts to sign the given message + /// * `i` - the index of the `y` component to be computed + fn compute_y_component(&self, rhoprime: &[u8; CRHBYTES], nonce: u16, i: u16) -> Poly { + let mut y_component: Poly = [0; N]; + // y[i]: poly_uniform_gamma1(&y->vec[i], seed, L*nonce + i); + let nonce = (L as u16 * nonce + i) as u16; + poly::uniform_gamma1m1(&mut y_component, rhoprime, nonce); + y_component + } + + /// Returns a random vector of `L` polynomials `y`. + /// + /// Computes the polynomial of vectors `y`, where: + /// - `y` is a vector of polynomials 'sampled' when signing using + /// `rhoprime` (based on`key`, `mu`, `nonce`) + /// + /// # Arguments + /// + /// * `rhoprime` - an array of bytes obrained as `SHA256(key || mu)` + /// * `nonce` - current count of the attempts to sign the given message + #[cfg(not(feature = "optimize_stack"))] + fn compute_y(&self, rhoprime: &[u8; CRHBYTES], nonce: u16) -> PolyVecL { + let mut y = PolyVecL::default(); + for i in 0..L { + y[i] = self.compute_y_component(rhoprime, nonce, i as u16) + } + y + } + + /// Returns the `i`-th component of `w = A * y`. + /// + /// Here: + /// - `A` is a matrix (part of the key): expanded from `rho` + /// - `y` is a vector of polynomials 'sampled' when signing using `rhoprime` + /// + /// Note that here `A` and `y` get recomputed in order to minimize the + /// stack usage. + /// + /// # Arguments + /// + /// * `rhoprime` - an array of bytes obrained as `SHA256(key || mu)` + /// * `nonce` - current count of the attempts to sign the given message + /// * `i` - the index of the `w` component to be computed + #[cfg(feature = "optimize_stack")] + fn compute_w_component(&self, rhoprime: &[u8; CRHBYTES], nonce: u16, i: usize) -> Poly { + let mut w_component: Poly = [0; N]; + + // w[i] = sum_j of A[i][j] * y[j] + for j in 0..L { + let mut y_component = self.compute_y_component(rhoprime, nonce, j as u16); + // nonce = nonce + 1; + poly::ntt(&mut y_component); + + // Expand the matrix and matrix-vector multiplication + let mut mat_component: Poly = [0; N]; + expand_mat_component(&self.rho, i, j, &mut mat_component); + polyvec::pointwise_acc_invmontgomery_componentwise( + &mut w_component, + &mat_component, + &y_component, + j, + ); + } + poly::reduce(&mut w_component); + poly::invntt_montgomery(&mut w_component); + poly::caddq(&mut w_component); + return w_component; + } + + /// Returns the vector of `K` polynomials `w = A * y`. + /// + /// Here: + /// - `A` is a matrix (part of the key): expanded from `rho` + /// - `y` is a vector of polynomials 'sampled' when signing using `rhoprime` + /// + /// In order to optimize the speed, we take `A` and `y` as parameters. + /// + /// # Arguments + /// + /// * `mat` - the matrix `A` + /// * `y` - the vector of polynomials `y` + #[cfg(not(feature = "optimize_stack"))] + fn compute_w(&self, mat: &[PolyVecL; K], y: &PolyVecL) -> PolyVecK { + let mut w = PolyVecK::default(); + let mut yhat = y.clone(); + yhat.ntt(); + for i in 0..K { + polyvec::pointwise_acc_invmontgomery(&mut w[i], &mat[i], &yhat); + } + + w.reduce(); + w.invntt_montgomery(); + w.caddq(); + + w + } + + /// Returns t[i], where `t = A * s1 + s2`, when optimizing stack usage. + /// + /// Here: + /// - `A` is a matrix (part of the key): expanded from `rho` + /// - `s1` is a vector of polynomials (part of the key) + /// - `s2` is a vector of polynomials (part of the key) + /// + /// Note that this function recomputes `A`, `s1`, and `s2` in order to + /// optimize the stack usage. + /// + /// # Arguments + /// * `i` - the index of the `t` component to be computed + #[cfg(feature = "optimize_stack")] + fn compute_t_component(&self, i: usize) -> Poly { + let mut t_component: Poly = [0; N]; + // Sample the matrix A and compute t[i] = sum_j A[i][j] * s1[j] + for j in 0..L { + // Resample s1[j] + let mut s1_component = self.compute_s1_component(j); + poly::ntt(&mut s1_component); + + let mut mat_component: Poly = [0; N]; + expand_mat_component(&self.rho, i, j, &mut mat_component); + + polyvec::pointwise_acc_invmontgomery_componentwise( + &mut t_component, + &mat_component, + &s1_component, + j, + ); + } + + poly::reduce(&mut t_component); + poly::invntt_montgomery(&mut t_component); + + // Unpack s2[i], compute t[i] = sum_j A[i][j] * s1[j] + s2[i] + { + let s2_component = self.compute_s2_component(i); + poly::add_assign(&mut t_component, &s2_component); + } + poly::caddq(&mut t_component); + + t_component + } + + /// Returns t[i], where `t = A * s1 + s2`, when optimizing speed. + /// + /// Here: + /// - `A` is a matrix (part of the key): expanded from `rho` + /// - `s1` is a vector of polynomials (part of the key) + /// - `s2` is a vector of polynomials (part of the key) + /// + /// In order to optimize the speed, we take `A`, `s1` and `s2` as + /// parameters. + /// + /// # Arguments + /// * `mat` - the matrix `A` + /// * `s1` - a vector of `L` polynomials in NTT format + /// * `s2` - a vector of `K` polynomials in standard format + /// * `i` - the index of the `t` component to be computed + #[cfg(not(feature = "optimize_stack"))] + fn compute_t_component( + &self, + mat: &[PolyVecL; K], + s1: &PolyVecL, + s2: &PolyVecK, + i: usize, + ) -> Poly { + let mut t_component: Poly = [0; N]; + + polyvec::pointwise_acc_invmontgomery(&mut t_component, &mat[i], &s1); + poly::reduce(&mut t_component); + poly::invntt_montgomery(&mut t_component); + poly::add_assign(&mut t_component, &s2[i]); + poly::caddq(&mut t_component); + + t_component + } + + /// Returns the the vector of `K` polynomials `t = A * s1 + s2`. + /// + /// Here: + /// - `A` is a matrix (part of the key): expanded from `rho` + /// - `s1` is a vector of polynomials (part of the key) + /// - `s2` is a vector of polynomials (part of the key) + /// + /// In order to optimize the speed, we take `A`, `s1` and `s2` as + /// parameters. + /// + /// # Arguments + /// * `mat` - the matrix `A` + /// * `s1` - a vector of `L` polynomials in NTT format + /// * `s2` - a vector of `K` polynomials in standard format + #[cfg(not(feature = "optimize_stack"))] + fn compute_t(&self, mat: &[PolyVecL; K], s1: &PolyVecL, s2: &PolyVecK) -> PolyVecK { + let mut t = PolyVecK::default(); + + for i in 0..K { + t[i] = self.compute_t_component(mat, s1, s2, i); + } + + t + } + + /// Returns the seed for generating the challenge polynomial. + /// + /// The seed is obtained as `SHA256(mu || encodings of 'commit' w1)`, where: + /// - `w1` contains the high bits of `w = A * y` + /// - `A` is a matrix (part of the key): expanded from `rho` + /// - `y` is a vector of polynomials 'sampled' when signing using `rhoprime`. + /// + /// In order to optimize the stack usage, this function recomputes `w`. + /// + /// # Arguments + /// + /// * `mu` - array of bytes containing the hashed input message + /// * `rhoprime` - an array of bytes obrained as `SHA256(key || mu)` + /// * `nonce` - current count of the attempts to sign the given message + #[cfg(feature = "optimize_stack")] + fn compute_c_seed( + &self, + mu: &[u8; CRHBYTES], + rhoprime: &[u8; CRHBYTES], + nonce: u16, + ) -> [u8; SEEDBYTES] { + let mut hasher = Shake256::default(); + hasher.process(mu); + for i in 0..K { + let w1_component = { + let w_component = self.compute_w_component(rhoprime, nonce, i); + poly::high_bits(&w_component) + }; + let mut pack = [0; POLW1_SIZE_PACKED]; + poly::w1_pack(&mut pack, &w1_component); + hasher.process(&pack); + } + + let mut xof = hasher.xof_result(); + let mut seed = [0u8; SEEDBYTES]; + xof.read(&mut seed); + seed + } + + /// Returns the seed for generating the challenge polynomial. + /// + /// The seed is obtained as `SHA256(mu || encodings of 'commit' w1)`, where: + /// - `w1` contains the high bits of `w = A * y` + /// - `A` is a matrix (part of the key): expanded from `rho` + /// - `y` is a vector of polynomials 'sampled' when signing using `rhoprime`. + /// + /// In order to optimize the speed, we take `w1` as a parameter. + /// + /// # Arguments + /// + /// * `mu` - array of bytes containing the hashed input message + /// * `w1` - an array of `K` polynomials. + #[cfg(not(feature = "optimize_stack"))] + fn compute_c_seed(&self, mu: &[u8; CRHBYTES], w1: &PolyVecK) -> [u8; SEEDBYTES] { + let mut hasher = Shake256::default(); + hasher.process(mu); + for i in 0..K { + let mut pack = [0; POLW1_SIZE_PACKED]; + poly::w1_pack(&mut pack, &w1[i]); + hasher.process(&pack); + } + + let mut xof = hasher.xof_result(); + let mut seed = [0u8; SEEDBYTES]; + xof.read(&mut seed); + seed + } + + /// Returns the `i`-th component of `s1` (part of the sk). + /// + /// # Arguments + /// * `i` - the index of the `s1` component to be computed + fn compute_s1_component(&self, i: usize) -> Poly { + let mut s1_component = [0; N]; + poly::eta_unpack(&mut s1_component, &self.s1_packed[i]); + s1_component + } + + /// Returns the vector of `L` polynomials `s1` (part of sk). + #[cfg(not(feature = "optimize_stack"))] + fn compute_s1(&self) -> PolyVecL { + let mut s1 = PolyVecL::default(); + + for i in 0..L { + s1[i] = self.compute_s1_component(i); + } + + s1 + } + + /// Returns the `i`-th component of `s2` (part of the sk). + /// + /// # Arguments + /// * `i` - the index of the `s1` component to be computed + fn compute_s2_component(&self, i: usize) -> Poly { + let mut s2_component = [0; N]; + poly::eta_unpack(&mut s2_component, &self.s2_packed[i]); + s2_component + } + + /// Returns the vector of `K` polynomials `s2` (part of sk). + #[cfg(not(feature = "optimize_stack"))] + fn compute_s2(&self) -> PolyVecK { + let mut s2 = PolyVecK::default(); + for i in 0..K { + s2[i] = self.compute_s2_component(i); + } + s2 + } + + /// Returns the `i`-th component of `z = y + c * s1`. + /// + /// Here: + /// - `y` is a vector of polynomials 'sampled' when signing using `rhoprime` + /// - `c` is the challenge polynomial based on `H(mu || 'commit' w1)` + /// - `s1` is part of the secret key + /// + /// Note that this function recomputes s1 and y in order to optimize the + /// stack usage. + /// + /// # Arguments + /// + /// * `rhoprime` - an array of bytes obrained as `SHA256(key || mu)` + /// * `c` - a polynomial in NTT format + /// * `nonce` - current count of the attempts to sign the given message + /// * `i` - the index of the `z` component to be computed + #[cfg(feature = "optimize_stack")] + fn compute_z_component( + &self, + rhoprime: &[u8; CRHBYTES], + c: &Poly, + nonce: u16, + i: usize, + ) -> Option { + let mut z_component: Poly; + // Compute c * s1. + { + let mut s1_component = self.compute_s1_component(i); + poly::ntt(&mut s1_component); + z_component = poly::multiply(&c, &s1_component); + } + + // Sample a component of the intermediate vector y and compute c * s1 + y. + { + let y_component = self.compute_y_component(rhoprime, nonce, i as u16); + poly::add_assign(&mut z_component, &y_component); + } + poly::reduce(&mut z_component); + + // Reject if z reveals secret. + if poly::chknorm(&z_component, GAMMA1 - BETA) { + None + } else { + Some(z_component) + } + } + + /// Returns the vector of `L` polynomials `z = c * s1 + y`. + /// + /// Here: + /// - `y` is a vector of polynomials 'sampled' when signing using `rhoprime` + /// - `c` is the challenge polynomial based on `H(mu || 'commit' w1)` + /// - `s1` is part of the secret key + /// + /// In order to optimize the speed, we take `s1` and `y` as parameters + /// instead of recomputing them. + /// + /// # Arguments + /// + /// * `c` - a polynomial in NTT format + /// * `s1` - a vector of `L` polynomials in NTT format + /// * `y` - a vector of `L` polynomials in standard format + #[cfg(not(feature = "optimize_stack"))] + fn compute_z(&self, c: &Poly, s1: &PolyVecL, y: &PolyVecL) -> Option { + let mut z = PolyVecL::default(); + for i in 0..L { + z[i] = poly::multiply(&c, &s1[i]); + } + + z.add_assign(y); + z.reduce(); + if z.chknorm(GAMMA1 - BETA) { + None + } else { + Some(z) + } + } + + /// Returns the `i`-th component of `w0cs2 = w0 - c * s2`. + /// + /// Here: + /// - `w0` contains the low bits of `w = A * y` + /// - `c` is the challenge polynomial based on `H(mu || 'commit' w1)` + /// - `s2` is part of the secret key + /// + /// Note that this function recomputes s2 to minimize the stack usage. + /// + /// # Arguments + /// + /// * `rhoprime` - an array of bytes obrained as `SHA256(key || mu)` + /// * `c` - a polynomial in NTT format + /// * `nonce` - current count of the attempts to sign the given message + /// * `i` - the index of the `w0cs2` component to be computed + #[cfg(feature = "optimize_stack")] + fn compute_w0cs2_component(&self, w_component: &Poly, c: &Poly, i: usize) -> Option { + let mut w0cs2_component: Poly = [0; N]; + { + // c * s2 + let cs2_component: Poly; + { + let mut s2_component = self.compute_s2_component(i); + poly::ntt(&mut s2_component); + cs2_component = poly::multiply(&c, &s2_component); + } + + // w0cs2 = w0 - cs2 = w0 - c * s2 + { + let w0_component = poly::low_bits(&w_component); + poly::sub(&mut w0cs2_component, &w0_component, &cs2_component); + } + + poly::reduce(&mut w0cs2_component); + } + + // Reject the attempt if the norm of w0cs2 is too high. + if poly::chknorm(&w0cs2_component, GAMMA2 - BETA) { + None + } else { + Some(w0cs2_component) + } + } + + /// Returns the vector of `K` polynomials `w0cs2 = w0 - c * s2`. + /// + /// Here: + /// - `w0` contains the low bits of `w = A * y` + /// - `c` is the challenge polynomial based on `H(mu || 'commit' w1)` + /// - `s2` is part of the secret key + /// + /// In order to optimize the speed, we take `w0` and `s2` as parameters + /// instead of recomputing them. + /// + /// # Arguments + /// + /// * `w0` - an array of `K` polynomials + /// * `c` - a polynomial in NTT format + /// * `s2` - a vector of K polynomials in NTT format + #[cfg(not(feature = "optimize_stack"))] + fn compute_w0cs2(&self, w0: &PolyVecK, c: &Poly, s2: &PolyVecK) -> Option { + // Compute c * s2 + let mut cs2 = PolyVecK::default(); + for i in 0..K { + cs2[i] = poly::multiply(&c, &s2[i]); + } + + // Compute w0 - cs2 + let mut w0cs2 = PolyVecK::default(); + w0cs2.with_sub(&w0, &cs2); + w0cs2.reduce(); + + if w0cs2.chknorm(GAMMA2 - BETA) { + None + } else { + Some(w0cs2) + } + } + + /// Returns the i-th component of `ct0 = c * t0`. + /// + /// Here: + /// - `c` is the challenge polynomial based on `H(mu || 'commit' w1)` + /// - `t0` is `t mod 2^D`, where `t = A * s1 + s2` + /// + /// Note that this function recomputes `A`, `s1`, and `s2`, in order to + /// minimize the stack usage. + /// + /// # Arguments + /// + /// * `c` - a polynomial in NTT format + /// * `i` - the index of the `ct0` component to be computed + #[cfg(feature = "optimize_stack")] + fn compute_ct0_component(&self, c: &Poly, i: usize) -> Option { + let ct0_component: Poly; + { + let mut t0_component = poly::power2round_remainder(&self.compute_t_component(i)); + poly::ntt(&mut t0_component); + ct0_component = poly::multiply(&c, &t0_component); + } + + if poly::chknorm(&ct0_component, GAMMA2) { + None + } else { + Some(ct0_component) + } + } + + /// Returns the vector of `K` polynomials `ct0 = c * t0`. + /// + /// Here: + /// - `c` is the challenge polynomial based on `H(mu || 'commit' w1)` + /// - `t0` is `t mod 2^D`, where `t = A * s1 + s2` + /// + /// This function takes `A`, `s1` and `s2` as parameters in order to + /// compute `t` with optimize speed. + /// + /// # Arguments + /// * `c` - a polynomial in NTT format + /// * `mat` - the matrix `A` + /// * `s1` - a vector of `L` polynomials in NTT format + /// * `s2` - a vector of `K` polynomials + #[cfg(not(feature = "optimize_stack"))] + fn compute_ct0( + &self, + c: &Poly, + mat: &[PolyVecL; K], + s1: &PolyVecL, + s2: &PolyVecK, + ) -> Option { + let t = self.compute_t(mat, s1, s2); + let mut t0 = PolyVecK::default(); + t.power2round_remainder(&mut t0); + t0.ntt(); + let mut ct0 = PolyVecK::default(); + for i in 0..K { + ct0[i] = poly::multiply(&c, &t0[i]); + } + + ct0.reduce(); + if ct0.chknorm(GAMMA2) { + None + } else { + Some(ct0) + } + } + + /// Attempts to compute a signature with the given parameters. + /// + /// The signature is computed deterministically using: + /// - `mu`(the hashed message) + /// - the `nonce` + /// + /// This function aims to minimize the stack usage, at the cost of speed. + /// + /// # Arguments + /// + /// * `mu` - array containing the hashed input message + /// * `nonce` - current count of the attempts to sign the given message + #[cfg(feature = "optimize_stack")] + fn try_sign_with_nonce( + &self, + mu: &[u8; CRHBYTES], + nonce: u16, + ) -> Option<[u8; SIG_SIZE_PACKED]> { + let mut sig = [0; SIG_SIZE_PACKED]; + + let mut rhoprime = [0u8; CRHBYTES]; + shake256!(&mut rhoprime; &self.key, mu); + + let c_seed = self.compute_c_seed(mu, &rhoprime, nonce); + let mut chat: Poly = poly::build_challenge_from_seed(&c_seed); + packing::sign::pack_c(&mut sig, &c_seed); + poly::ntt(&mut chat); + + let mut hint = 0; + let mut hint_non_zero_coeff_index = 0; + + for i in 0..K { + // The verifier needs the hint for the difference between + // tmp = w0 - c * s2 + c * t0 and w1 to recompute w. + let mut h_component: Poly = [0; N]; + { + // Recompute the i-th component of w1: the high bits of w = A * y + let w_component: Poly = self.compute_w_component(&rhoprime, nonce, i); + + // Compute i-th component of w0cs2 = w0 - c * s2, where w0 = the low bits of w + let w0cs2_component: Poly = self.compute_w0cs2_component(&w_component, &chat, i)?; + + let mut tmp_component: Poly = [0; N]; + { + // Compute the i-th component of ct0 = c * t0 + let ct0_component: Poly = self.compute_ct0_component(&chat, i)?; + poly::add(&mut tmp_component, &w0cs2_component, &ct0_component); + } + + let w1_component = poly::high_bits(&w_component); + + hint += poly::make_hint(&tmp_component, &w1_component, &mut h_component); + } + + if hint > OMEGA { + return None; + } + + packing::sign::pack_h_component( + &mut sig, + &h_component, + i, + &mut hint_non_zero_coeff_index, + ); + } + + // Computing z = y + cs1 + for i in 0..L { + let z_component: Poly = self.compute_z_component(&rhoprime, &chat, nonce, i)?; + packing::sign::pack_z_component(&mut sig, &z_component, i); + } + + Some(sig) + } + + /// Attempts to compute a signature with the given parameters. + /// + /// The signature is computed deterministically using: + /// - `mu`(the hashed message) + /// - the `nonce` + /// + /// This function aims to minimize the speed, at the cost of stack usage. + /// + /// # Arguments + /// + /// * `mu` - array containing the hashed input message + /// * `nonce` - current count of the attempts to sign the given message + #[cfg(not(feature = "optimize_stack"))] + fn try_sign_with_nonce( + &self, + mu: &[u8; CRHBYTES], + nonce: u16, + ) -> Option<[u8; SIG_SIZE_PACKED]> { + let mut rhoprime = [0u8; CRHBYTES]; + shake256!(&mut rhoprime; &self.key, mu); + + let mut sig = [0; SIG_SIZE_PACKED]; + + // Sample intermediate vector + let y = self.compute_y(&rhoprime, nonce); + + // Matrix-vector multiplication + let mut mat = [PolyVecL::default(); K]; + expand_mat(&self.rho, &mut mat); + + let w = self.compute_w(&mat, &y); + + // Decompose w and call the random oracle + let (mut w0, mut w1) = (PolyVecK::default(), PolyVecK::default()); + w.decompose(&mut w0, &mut w1); + + // Compute challenge + let c_seed = self.compute_c_seed(mu, &w1); + packing::sign::pack_c(&mut sig, &c_seed); + let mut c: Poly = poly::build_challenge_from_seed(&c_seed); + poly::ntt(&mut c); + + // Compute z, reject if it reveals secret + let mut s1 = self.compute_s1(); + s1.ntt(); + let z = self.compute_z(&c, &s1, &y)?; + packing::sign::pack_z(&mut sig, &z); + + // Compute ct0 = c * t0 + let mut s2 = self.compute_s2(); + let ct0 = self.compute_ct0(&c, &mat, &s1, &s2)?; + + // Compute w0 - c * s2, reject if w1 can not be computed from it + s2.ntt(); + let w0cs2 = self.compute_w0cs2(&w0, &c, &s2)?; + + // The verifier needs the hint for the difference between + // tmp = w0 - c * s2 + c * t0 and w1 to recompute w. + let mut tmp = PolyVecK::default(); + tmp.with_add(&w0cs2, &ct0); + let mut h = PolyVecK::default(); + let hint = polyvec::make_hint(&tmp, &w1, &mut h); + if hint > OMEGA { + return None; + }; + packing::sign::pack_h(&mut sig, &h); + + return Some(sig); + } + + /// Returns a signature for the given message. + /// + /// # Arguments + /// + /// * `m` - the message to be signed. + pub fn sign(&self, m: &[u8]) -> [u8; SIG_SIZE_PACKED] { + // Compute CRH(tr, msg) + let mut mu = [0u8; CRHBYTES]; + shake256!(&mut mu; &self.tr, m); + + let mut nonce = 0; + + // The probability that multiple iterations are needed is very low. + // More details can be found in section 3.2: + // https://eprint.iacr.org/2017/633.pdf + // TODO(dianamin): Add an artificial break after some number of iterations. + loop { + match self.try_sign_with_nonce(&mu, nonce) { + Some(sig) => break sig, + None => nonce = nonce + 1 as u16, + } + } + } +} + +impl Default for PubKey { + fn default() -> PubKey { + PubKey { + rho: [0; SEEDBYTES], + t1_packed: [[0; POLT1_SIZE_PACKED]; K], + } + } +} + +impl PubKey { + /// Encodes the public key into an array of bytes. + /// + /// Fills the bytes array as follows: + /// `rho || encodings of t1` + /// + /// # Arguments + /// + /// * `bytes` - an array of bytes where the encoding will be stored. + pub fn to_bytes(&self, bytes: &mut [u8; PK_SIZE_PACKED]) { + let mut offset = 0; + let mut push = |data: &[u8]| { + bytes[offset..][..data.len()].copy_from_slice(data); + offset += data.len(); + }; + + push(&self.rho); + for i in 0..K { + push(&self.t1_packed[i]); + } + } + + /// Decodes the public key from an array of bytes. + /// + /// Extracts the fields from a bytes array with the following shape: + /// `rho || encodings of t1` + /// + /// # Arguments + /// + /// * `bytes` - the array of bytes containing the encoding. + pub fn from_bytes(bytes: &[u8; PK_SIZE_PACKED]) -> PubKey { + let mut offset = 0; + let mut pull = |data: &mut [u8]| { + data.copy_from_slice(&bytes[offset..][..data.len()]); + offset += data.len(); + }; + + let mut pk = PubKey::default(); + pull(&mut pk.rho); + for i in 0..K { + pull(&mut pk.t1_packed[i]); + } + pk + } + + /// Computes the seed needed to generate c: `SHA256(mu || encodings of w1)`. + /// + /// # Arguments + /// + /// * `mu` - the hashed message + /// * `w1` - a vector of `K` polynomials + fn compute_c_seed(&self, mu: &[u8; CRHBYTES], w1: &PolyVecK) -> [u8; SEEDBYTES] { + let mut outbuf = [0u8; SEEDBYTES]; + let mut w1pack = [0u8; K * POLW1_SIZE_PACKED]; + for (i, pack) in w1pack.chunks_mut(POLW1_SIZE_PACKED).enumerate() { + let pack = array_mut_ref!(pack, 0, POLW1_SIZE_PACKED); + poly::w1_pack(pack, &w1[i]); + } + let mut hasher = Shake256::default(); + hasher.process(mu); + hasher.process(&w1pack); + let mut xof = hasher.xof_result(); + xof.read(&mut outbuf); + + outbuf + } + + // TODO(dianamin): Refactor this function. + /// Verifies the given signature for the given message. + /// + /// # Arguments + /// + /// * `m` - the message + /// * `sig` - the signature to be verified + pub fn verify(&self, m: &[u8], sig: &[u8; SIG_SIZE_PACKED]) -> bool { + let mut pk = [0; PK_SIZE_PACKED]; + self.to_bytes(&mut pk); + let (mut rho, mut mu) = ([0; SEEDBYTES], [0; CRHBYTES]); + + let mut c = [0u8; SEEDBYTES]; + let mut z = PolyVecL::default(); + let (mut t1, mut w1, mut h) = Default::default(); + let (mut tmp1, mut tmp2) = (PolyVecK::default(), PolyVecK::default()); + + packing::pk::unpack(&pk, &mut rho, &mut t1); + let r = packing::sign::unpack(sig, &mut c, &mut z, &mut h); + + if !r { + return false; + }; + if z.chknorm(GAMMA1 - BETA) { + return false; + }; + + // Compute CRH(CRH(rho, t1), msg) + shake256!(&mut mu[0..SEEDBYTES]; &pk); + shake256!(&mut mu[0..CRHBYTES]; &mu[0..SEEDBYTES], m); + + // Expand matrix and matrix-vector multiplication; compute Az - c2^dt1 + z.ntt(); + for i in 0..K { + for j in 0..L { + let mut mat_component: Poly = [0; N]; + expand_mat_component(&self.rho, i, j, &mut mat_component); + polyvec::pointwise_acc_invmontgomery_componentwise( + &mut tmp1[i], + &mat_component, + &z[j], + j, + ); + } + } + + let cp = poly::build_challenge_from_seed(&c); + let mut chat = cp.clone(); + poly::ntt(&mut chat); + t1.shift_left(); + t1.ntt(); + for i in 0..K { + poly::pointwise_invmontgomery(&mut tmp2[i], &chat, &t1[i]); + } + + let mut tmp = PolyVecK::default(); + tmp.with_sub(&tmp1, &tmp2); + tmp.reduce(); + tmp.invntt_montgomery(); + + // Reconstruct w1 + tmp.caddq(); + polyvec::use_hint(&mut w1, &tmp, &h); + + // Call random oracle and verify challenge + let c2 = self.compute_c_seed(&mu, &w1); + + for i in 0..SEEDBYTES { + if c[i] != c2[i] { + return false; + } + } + + true + } +} diff --git a/third_party/dilithium/src/test_mul.rs b/third_party/dilithium/src/test_mul.rs new file mode 100644 index 0000000..eb5a260 --- /dev/null +++ b/third_party/dilithium/src/test_mul.rs @@ -0,0 +1,64 @@ +extern crate rng256; + +use super::*; +use params::{N, Q}; +use poly::Poly; + +const NTESTS: usize = 10000; + +fn poly_naivemul(c: &mut Poly, a: &Poly, b: &Poly) { + let mut r = [0; 2 * N]; + + for i in 0..N { + for j in 0..N { + r[i + j] += (((a[i] as i64) * (b[j] as i64)) % (Q as i64)) as i32; + } + } + + for i in N..(2 * N) { + r[i - N] = (r[i - N] - r[i]) % Q; + } + + c.copy_from_slice(&r[..N]); +} + +#[test] +fn test_mul() { + use self::rng256::Rng256; + + let mut rndbuf = [0; 32]; + let mut c = [0; N]; + let (mut c1, mut c2) = ([0; N], [0; N]); + let (mut a, mut b) = ([0; N], [0; N]); + + let mut rng = rng256::ThreadRng256 {}; + + for _ in 0..NTESTS { + rng.fill_bytes(&mut rndbuf); + poly::uniform(&mut a, &rndbuf, 0); + rng.fill_bytes(&mut rndbuf); + poly::uniform(&mut b, &rndbuf, 0); + + c.copy_from_slice(&a[..N]); + poly::ntt(&mut c); + for j in 0..N { + c[j] = ((c[j] as i64) * -114592 % (Q as i64)) as i32; + } + poly::invntt_montgomery(&mut c); + + for j in 0..N { + assert_eq!((c[j] - a[j]) % Q, 0); + } + + poly_naivemul(&mut c1, &a, &b); + + poly::ntt(&mut a); + poly::ntt(&mut b); + poly::pointwise_invmontgomery(&mut c2, &a, &b); + poly::invntt_montgomery(&mut c2); + + for j in 0..N { + assert_eq!((c1[j] - c2[j]) % Q, 0); + } + } +} diff --git a/third_party/dilithium/src/utils.rs b/third_party/dilithium/src/utils.rs new file mode 100644 index 0000000..9b3f13a --- /dev/null +++ b/third_party/dilithium/src/utils.rs @@ -0,0 +1,10 @@ +macro_rules! shake256 { + ( $output:expr ; $( $input:expr ),* ) => { + let mut hasher = ::sha3::Shake256::default(); + $( + ::digest::Input::process(&mut hasher, $input); + )* + let mut reader = ::digest::ExtendableOutput::xof_result(hasher); + ::digest::XofReader::read(&mut reader, $output); + } +} diff --git a/third_party/dilithium/tests/dilithium_c.rs b/third_party/dilithium/tests/dilithium_c.rs new file mode 100644 index 0000000..cd7a7ac --- /dev/null +++ b/third_party/dilithium/tests/dilithium_c.rs @@ -0,0 +1,3548 @@ +// Comparing the signatures obtained by the c++ implementation of Dilithium +// to our results. +// https://github.com/pq-crystals/dilithium/tree/master/ref + +extern crate arrayref; +extern crate digest; +extern crate dilithium; +extern crate rng256; +extern crate sha3; + +use dilithium::params::*; +use dilithium::sign::SecKey; + +fn check( + message: &[u8], + sk_bytes: &[u8; SK_SIZE_PACKED_ORIGINAL], + expected_pk_bytes: &[u8; PUBLICKEYBYTES], + expected_sig_bytes: &[u8; BYTES], +) -> bool { + let sk = SecKey::from_bytes_original(&sk_bytes); + + // checking pk + let pk = sk.genpk(); + let mut pk_bytes = [0; PUBLICKEYBYTES]; + pk.to_bytes(&mut pk_bytes); + if pk_bytes != *expected_pk_bytes { + return false; + } + + let sig_bytes = sk.sign(&message); + + if sig_bytes != *expected_sig_bytes { + return false; + } + + return true; +} + +fn check_sk(seed: &[u8; SEEDBYTES], expected_sk_bytes: &[u8; SK_SIZE_PACKED_ORIGINAL]) -> bool { + let sk = SecKey::gensk_from_seed(seed); + + let mut sk_bytes = [0; SK_SIZE_PACKED_ORIGINAL]; + sk.to_bytes_original(&mut sk_bytes); + + if sk_bytes != *expected_sk_bytes { + return false; + } + + return true; +} + +#[cfg(feature = "dilithium2")] +#[test] +fn test_dilithium_c_sk() { + let seed = [ + 209, 102, 199, 255, 59, 121, 79, 122, 81, 202, 129, 157, 44, 119, 82, 109, 20, 243, 59, 21, + 241, 74, 70, 181, 172, 2, 187, 188, 35, 0, 189, 179, + ]; + let expected_sk_bytes = [ + 231, 48, 130, 50, 218, 44, 18, 127, 63, 8, 61, 127, 0, 80, 16, 93, 29, 192, 104, 2, 46, 87, + 61, 46, 18, 205, 236, 205, 51, 122, 17, 175, 166, 80, 171, 102, 40, 205, 195, 37, 221, 29, + 251, 19, 72, 99, 188, 96, 30, 134, 224, 188, 95, 8, 60, 201, 20, 228, 4, 135, 152, 169, + 215, 51, 21, 182, 66, 98, 175, 100, 111, 160, 190, 1, 39, 208, 11, 70, 250, 63, 197, 182, + 180, 95, 252, 0, 202, 236, 155, 180, 140, 200, 109, 94, 32, 210, 28, 130, 136, 160, 24, 12, + 9, 71, 96, 193, 0, 12, 18, 1, 106, 35, 33, 144, 8, 64, 12, 196, 38, 132, 1, 150, 141, 75, + 52, 46, 201, 66, 68, 66, 0, 16, 9, 68, 129, 20, 25, 130, 99, 184, 68, 194, 192, 73, 128, + 22, 48, 154, 132, 68, 195, 152, 4, 97, 68, 141, 17, 180, 112, 9, 3, 16, 194, 6, 97, 228, + 68, 32, 153, 16, 37, 96, 22, 50, 220, 196, 16, 33, 145, 133, 218, 162, 132, 64, 38, 100, + 66, 56, 6, 1, 9, 42, 34, 162, 45, 66, 160, 65, 224, 56, 37, 20, 2, 141, 97, 24, 5, 132, + 148, 12, 81, 4, 1, 20, 177, 33, 26, 40, 130, 1, 150, 68, 162, 72, 36, 154, 160, 5, 226, 38, + 145, 24, 40, 9, 33, 200, 48, 26, 22, 109, 11, 21, 110, 220, 72, 76, 18, 196, 77, 8, 41, 14, + 203, 4, 50, 1, 2, 105, 84, 56, 138, 33, 164, 0, 4, 6, 112, 36, 135, 68, 209, 22, 0, 3, 57, + 41, 68, 50, 78, 64, 176, 44, 212, 34, 129, 209, 16, 77, 208, 56, 74, 64, 70, 50, 9, 34, 76, + 128, 16, 50, 26, 199, 132, 227, 130, 77, 2, 177, 17, 80, 150, 4, 26, 23, 12, 18, 165, 104, + 36, 164, 105, 140, 194, 65, 211, 54, 74, 1, 20, 1, 67, 180, 9, 34, 39, 10, 97, 182, 145, 8, + 132, 37, 72, 2, 72, 227, 162, 96, 73, 4, 70, 82, 50, 109, 27, 67, 45, 162, 20, 106, 16, 55, + 50, 27, 64, 96, 1, 36, 37, 147, 16, 70, 34, 55, 109, 97, 50, 38, 68, 152, 9, 216, 48, 76, + 17, 51, 38, 90, 0, 138, 128, 164, 97, 139, 6, 74, 153, 68, 97, 97, 36, 132, 155, 148, 113, + 92, 194, 44, 100, 38, 78, 211, 66, 16, 144, 132, 141, 195, 34, 138, 193, 52, 45, 36, 20, + 138, 194, 34, 134, 129, 64, 73, 27, 23, 138, 9, 145, 4, 81, 48, 10, 216, 132, 13, 128, 32, + 34, 81, 22, 36, 0, 177, 76, 28, 177, 48, 27, 180, 132, 212, 54, 80, 24, 24, 109, 3, 21, + 105, 16, 54, 38, 2, 199, 37, 152, 48, 96, 34, 161, 76, 139, 40, 142, 34, 18, 145, 97, 36, + 41, 0, 193, 17, 218, 132, 5, 224, 72, 40, 72, 66, 98, 34, 34, 98, 100, 48, 12, 146, 68, 0, + 211, 152, 136, 76, 72, 108, 200, 68, 108, 17, 7, 16, 218, 70, 66, 90, 180, 36, 36, 195, + 105, 9, 4, 133, 10, 169, 113, 148, 70, 82, 9, 23, 96, 19, 70, 40, 194, 34, 70, 8, 3, 8, + 192, 0, 140, 161, 196, 100, 9, 144, 16, 11, 193, 112, 88, 40, 77, 209, 146, 77, 193, 196, + 129, 35, 179, 133, 139, 22, 82, 80, 200, 72, 131, 130, 129, 35, 48, 37, 196, 48, 78, 65, + 48, 38, 67, 150, 129, 88, 22, 38, 148, 2, 50, 193, 38, 4, 194, 48, 16, 17, 52, 6, 201, 38, + 136, 146, 198, 136, 3, 166, 76, 11, 4, 128, 161, 48, 73, 92, 50, 81, 146, 134, 97, 73, 162, + 128, 96, 128, 9, 137, 56, 102, 34, 168, 37, 27, 67, 36, 82, 6, 136, 74, 18, 105, 76, 36, + 18, 74, 164, 37, 152, 200, 64, 200, 52, 134, 24, 136, 33, 204, 22, 133, 162, 68, 78, 65, + 200, 112, 137, 146, 49, 212, 194, 41, 153, 152, 77, 164, 52, 76, 28, 129, 132, 148, 6, 36, + 88, 40, 73, 128, 40, 130, 220, 20, 46, 228, 162, 9, 26, 22, 76, 136, 22, 69, 12, 4, 101, + 35, 4, 74, 160, 194, 73, 33, 200, 112, 89, 48, 65, 17, 169, 144, 138, 68, 40, 10, 7, 38, + 147, 50, 137, 32, 6, 34, 36, 162, 105, 97, 18, 65, 154, 180, 129, 25, 9, 132, 193, 70, 65, + 220, 68, 82, 12, 54, 40, 18, 71, 13, 227, 20, 46, 154, 16, 130, 227, 38, 140, 20, 131, 65, + 10, 177, 1, 212, 152, 5, 209, 8, 102, 201, 54, 45, 0, 19, 104, 18, 37, 145, 0, 40, 8, 202, + 24, 44, 137, 194, 129, 140, 22, 72, 160, 196, 33, 193, 24, 104, 144, 20, 65, 8, 132, 77, + 28, 56, 133, 11, 199, 129, 8, 71, 74, 144, 68, 109, 11, 4, 68, 148, 20, 5, 34, 16, 69, 17, + 65, 98, 144, 6, 1, 35, 70, 49, 27, 147, 37, 84, 40, 34, 146, 182, 140, 90, 162, 13, 122, + 179, 58, 0, 122, 212, 66, 42, 229, 55, 253, 121, 195, 136, 207, 72, 180, 118, 33, 108, 75, + 136, 175, 25, 70, 50, 37, 243, 78, 154, 98, 33, 33, 167, 125, 190, 105, 188, 178, 187, 89, + 57, 206, 252, 132, 119, 52, 48, 114, 127, 9, 116, 252, 128, 187, 61, 117, 230, 253, 130, + 182, 185, 239, 96, 116, 75, 172, 153, 195, 187, 44, 138, 231, 130, 147, 30, 116, 224, 2, + 182, 220, 230, 102, 98, 1, 198, 112, 13, 122, 34, 188, 205, 241, 217, 190, 179, 0, 96, 140, + 226, 140, 247, 186, 20, 106, 156, 63, 205, 207, 203, 210, 186, 53, 17, 247, 199, 44, 70, 8, + 130, 118, 233, 130, 231, 28, 180, 52, 157, 228, 227, 139, 94, 176, 249, 77, 152, 64, 37, + 249, 85, 240, 216, 131, 250, 192, 206, 213, 226, 230, 65, 194, 182, 250, 69, 169, 170, 13, + 51, 246, 165, 22, 28, 86, 155, 244, 185, 102, 153, 94, 61, 180, 213, 17, 218, 209, 134, + 191, 93, 146, 37, 71, 12, 27, 85, 167, 248, 97, 88, 187, 229, 225, 231, 4, 102, 225, 176, + 237, 11, 130, 13, 147, 214, 51, 192, 194, 52, 200, 120, 209, 181, 3, 3, 222, 187, 212, 212, + 57, 54, 125, 5, 46, 148, 71, 130, 203, 162, 253, 252, 41, 220, 95, 81, 48, 70, 43, 10, 229, + 27, 143, 150, 51, 86, 36, 2, 168, 57, 211, 96, 24, 74, 240, 229, 62, 140, 211, 133, 43, + 166, 133, 251, 208, 5, 179, 201, 196, 149, 0, 23, 130, 148, 79, 71, 254, 30, 188, 66, 219, + 244, 54, 203, 113, 168, 82, 79, 93, 88, 131, 201, 45, 76, 156, 232, 57, 106, 26, 253, 35, + 100, 225, 176, 194, 155, 37, 227, 49, 36, 224, 32, 114, 16, 11, 188, 40, 111, 9, 171, 224, + 31, 171, 251, 15, 2, 86, 220, 163, 121, 195, 17, 206, 251, 96, 151, 148, 31, 96, 33, 185, + 94, 41, 158, 168, 172, 161, 250, 84, 74, 180, 148, 126, 246, 138, 224, 217, 71, 151, 118, + 26, 148, 220, 244, 208, 211, 23, 192, 91, 250, 15, 91, 174, 7, 214, 199, 61, 4, 43, 36, + 136, 150, 109, 246, 33, 70, 154, 122, 142, 29, 224, 255, 105, 157, 255, 75, 161, 229, 142, + 12, 183, 29, 182, 251, 128, 220, 226, 6, 95, 234, 204, 83, 27, 204, 117, 159, 230, 24, 42, + 82, 169, 139, 177, 29, 6, 113, 84, 109, 117, 124, 134, 62, 254, 72, 120, 10, 200, 85, 196, + 29, 162, 251, 124, 134, 134, 248, 192, 9, 233, 27, 54, 194, 219, 202, 183, 17, 2, 163, 102, + 114, 224, 208, 248, 45, 44, 120, 107, 168, 146, 114, 197, 32, 88, 28, 27, 249, 0, 207, 155, + 3, 120, 153, 143, 90, 248, 243, 70, 91, 142, 125, 159, 56, 99, 3, 166, 215, 221, 74, 110, + 19, 132, 53, 182, 247, 79, 134, 81, 253, 101, 56, 131, 197, 149, 154, 248, 178, 189, 174, + 218, 37, 28, 223, 248, 248, 187, 102, 180, 224, 248, 27, 235, 4, 125, 48, 126, 89, 204, 23, + 26, 234, 7, 44, 187, 140, 244, 78, 228, 35, 194, 196, 70, 228, 48, 188, 231, 118, 58, 254, + 153, 178, 18, 205, 68, 36, 238, 185, 15, 6, 190, 65, 161, 254, 243, 254, 242, 88, 53, 6, + 248, 130, 46, 94, 168, 104, 106, 10, 242, 150, 36, 152, 159, 35, 98, 212, 43, 93, 107, 61, + 155, 87, 53, 86, 217, 163, 180, 225, 83, 171, 84, 199, 199, 241, 95, 34, 107, 173, 60, 193, + 178, 98, 211, 206, 254, 199, 210, 218, 184, 94, 35, 224, 238, 125, 228, 110, 62, 0, 64, + 212, 234, 58, 44, 188, 235, 185, 30, 175, 67, 112, 124, 217, 63, 74, 126, 136, 171, 14, + 237, 84, 139, 103, 248, 83, 198, 60, 86, 14, 118, 200, 103, 212, 188, 104, 124, 52, 164, + 140, 30, 221, 45, 24, 40, 219, 80, 141, 64, 14, 186, 95, 246, 40, 131, 32, 165, 206, 40, + 216, 17, 225, 27, 240, 183, 24, 70, 7, 43, 18, 59, 90, 203, 231, 110, 205, 4, 169, 204, + 255, 161, 160, 194, 101, 252, 129, 245, 14, 242, 28, 51, 96, 244, 247, 252, 4, 88, 39, 219, + 226, 63, 253, 214, 5, 12, 163, 235, 175, 80, 102, 194, 221, 106, 133, 44, 130, 193, 174, + 109, 104, 175, 124, 183, 250, 146, 221, 115, 54, 204, 108, 40, 26, 171, 23, 11, 141, 213, + 248, 39, 17, 250, 172, 227, 130, 126, 186, 146, 190, 118, 62, 152, 27, 195, 232, 83, 105, + 74, 8, 85, 164, 20, 221, 92, 36, 62, 158, 16, 105, 40, 250, 125, 215, 231, 88, 133, 170, + 84, 120, 147, 231, 209, 38, 123, 222, 204, 223, 174, 55, 255, 189, 132, 56, 20, 243, 7, + 121, 63, 48, 222, 38, 215, 69, 135, 15, 139, 60, 64, 175, 29, 72, 5, 21, 120, 142, 132, 84, + 201, 71, 169, 102, 11, 112, 179, 72, 224, 33, 54, 63, 201, 51, 76, 227, 68, 46, 251, 204, + 78, 110, 140, 60, 9, 245, 155, 143, 128, 148, 51, 172, 131, 139, 151, 73, 214, 35, 154, + 145, 78, 246, 92, 28, 124, 182, 17, 165, 146, 25, 125, 241, 107, 10, 197, 10, 25, 87, 27, + 126, 117, 43, 4, 168, 244, 184, 152, 142, 123, 65, 160, 170, 114, 87, 181, 45, 37, 39, 123, + 178, 180, 76, 233, 198, 105, 120, 129, 33, 44, 7, 114, 178, 198, 116, 245, 117, 171, 121, + 184, 174, 133, 109, 172, 227, 177, 233, 179, 187, 183, 229, 41, 19, 198, 6, 251, 81, 152, + 216, 206, 176, 165, 244, 118, 69, 26, 146, 112, 213, 204, 185, 37, 142, 212, 255, 184, 182, + 66, 244, 124, 130, 12, 109, 131, 244, 13, 189, 22, 143, 215, 211, 33, 111, 191, 137, 253, + 234, 134, 132, 32, 202, 195, 143, 208, 193, 129, 32, 77, 241, 8, 202, 231, 179, 159, 21, + 19, 185, 23, 5, 189, 73, 178, 39, 213, 228, 35, 36, 212, 98, 227, 178, 61, 234, 69, 163, + 48, 175, 130, 128, 149, 186, 44, 130, 185, 65, 50, 72, 244, 239, 112, 242, 148, 162, 249, + 10, 42, 66, 61, 34, 66, 150, 239, 153, 228, 2, 197, 138, 100, 137, 152, 238, 113, 28, 210, + 141, 122, 123, 71, 217, 104, 156, 231, 59, 233, 109, 186, 245, 241, 5, 46, 122, 105, 162, + 163, 214, 48, 173, 173, 14, 41, 43, 111, 42, 138, 185, 150, 211, 58, 208, 226, 38, 82, 134, + 194, 119, 8, 131, 67, 54, 186, 208, 1, 195, 120, 28, 87, 91, 172, 75, 13, 34, 147, 176, 0, + 119, 200, 46, 97, 214, 156, 143, 211, 107, 92, 159, 84, 153, 161, 92, 200, 200, 39, 174, + 39, 113, 33, 242, 192, 9, 3, 133, 217, 255, 232, 26, 29, 125, 107, 108, 158, 161, 68, 109, + 241, 159, 140, 138, 114, 188, 219, 20, 51, 120, 88, 202, 98, 244, 48, 40, 200, 201, 8, 149, + 103, 224, 140, 209, 152, 23, 166, 255, 227, 216, 244, 92, 220, 107, 85, 102, 51, 18, 45, + 182, 126, 159, 149, 245, 190, 93, 75, 157, 53, 20, 83, 253, 63, 7, 121, 186, 119, 209, 173, + 53, 52, 6, 150, 185, 9, 45, 19, 213, 133, 139, 53, 208, 33, 30, 73, 99, 33, 2, 235, 151, + 50, 125, 146, 75, 241, 173, 103, 4, 176, 217, 198, 241, 220, 32, 22, 29, 13, 198, 11, 24, + 17, 144, 100, 251, 27, 111, 107, 173, 5, 123, 31, 55, 49, 193, 213, 50, 64, 7, 101, 117, + 244, 63, 49, 204, 62, 85, 156, 229, 4, 47, 221, 177, 161, 248, 238, 119, 96, 65, 151, 131, + 115, 118, 49, 195, 29, 176, 239, 200, 236, 83, 254, 184, 97, 41, 43, 77, 254, 171, 39, 230, + 114, 207, 47, 69, 165, 19, 6, 133, 160, 17, 40, 108, 18, 197, 18, 128, 150, 51, 18, 134, + 111, 46, 197, 115, 205, 4, 224, 5, 43, 115, 219, 42, 60, 41, 73, 107, 41, 124, 44, 179, + 170, 164, 28, 78, 94, 205, 248, 22, 103, 207, 187, 125, 167, 214, 101, 2, 14, 239, 46, 8, + 105, 122, 98, 129, 63, 165, 227, 98, 175, 32, 83, 194, 199, 213, 23, 192, 182, 166, 136, + 140, 222, 138, 211, 32, 35, 212, 145, 137, 162, 124, 58, 0, 241, 29, 72, 233, 133, 175, 50, + 57, 17, 206, 65, 133, 102, 247, 108, 148, 62, 234, 156, 178, 156, 36, 82, 182, 57, 224, 47, + 13, 106, 138, 40, 123, 38, 59, 194, 57, 83, 215, 237, 182, 142, 91, 201, 109, 44, 131, 63, + 246, 118, 116, 239, 154, 102, 27, 227, 34, 205, 85, 44, 115, 235, 220, 101, 246, 178, 154, + 145, 112, 202, 9, 185, 43, 164, 48, 134, 45, 119, 120, 129, 112, 15, 37, 191, 53, 184, 233, + 107, 117, 140, 99, 220, 149, 187, 176, 228, 144, 194, 112, 134, 164, 211, 217, 148, 132, + 170, 18, 204, 169, 239, 104, 232, 98, 123, 28, 12, 135, 186, 148, 58, 64, 242, 71, 200, + 121, 133, 145, 70, 196, 131, 128, 240, 105, 65, 41, 232, 211, 103, 155, 224, 3, 90, 23, + 177, 198, 124, 212, 118, 96, 17, 109, 7, 67, 38, 172, 36, 222, 163, 29, 36, 107, 97, 15, + 202, 218, 140, 179, 5, 194, 201, 33, 149, 83, 86, 239, 165, 242, 101, 114, 5, 135, 123, + 159, 188, 193, 136, 241, 164, 210, 201, 94, 243, 143, 65, 173, 165, 227, 52, 202, 32, 47, + 174, 234, 90, 48, 165, 82, 27, 206, 203, 254, 186, 189, 170, 220, 93, 120, 186, 172, 112, + 42, 175, 37, 235, 81, 110, 74, 43, 166, 70, 43, 129, 193, + ]; + + assert!(check_sk(&seed, &expected_sk_bytes)); +} + +#[cfg(feature = "dilithium2")] +#[test] +fn test_dilithium_c_fixed_sk() { + let message = [ + 78, 188, 201, 152, 24, 130, 6, 156, 27, 134, 139, 93, 120, 56, 11, 29, 52, 253, 34, 47, + 244, 66, 82, 171, 242, 128, 139, 52, 165, 98, 103, 54, 80, 128, 214, 74, 22, 177, 133, 172, + 237, 133, 25, 25, 133, 224, 28, 13, 86, 36, 104, 199, 229, 140, 75, 29, 222, 198, 188, + ]; + let sk_bytes = [ + 80, 31, 193, 46, 100, 86, 79, 62, 184, 160, 173, 26, 122, 204, 110, 125, 224, 72, 30, 57, + 97, 119, 139, 57, 40, 194, 81, 43, 190, 78, 129, 42, 67, 37, 234, 12, 137, 117, 188, 9, 53, + 121, 27, 87, 56, 224, 105, 1, 147, 70, 151, 20, 101, 236, 129, 103, 205, 49, 77, 209, 84, + 229, 251, 80, 237, 144, 1, 148, 236, 243, 98, 75, 219, 80, 241, 153, 42, 191, 236, 201, + 234, 238, 252, 74, 117, 144, 166, 104, 137, 208, 187, 215, 242, 14, 237, 154, 80, 130, 132, + 66, 56, 133, 33, 197, 69, 4, 68, 12, 64, 150, 140, 33, 5, 38, 65, 70, 98, 10, 133, 73, 91, + 56, 66, 227, 148, 32, 204, 6, 36, 17, 57, 9, 82, 198, 9, 76, 134, 80, 227, 4, 76, 27, 185, + 144, 219, 6, 138, 9, 70, 0, 83, 136, 0, 153, 66, 129, 153, 8, 10, 35, 32, 145, 18, 167, 0, + 144, 146, 129, 194, 48, 12, 212, 136, 133, 36, 147, 145, 28, 52, 36, 212, 22, 16, 16, 21, + 102, 131, 198, 72, 75, 200, 65, 73, 128, 40, 25, 20, 128, 209, 40, 46, 156, 48, 136, 16, + 167, 68, 208, 150, 96, 193, 66, 66, 3, 195, 112, 152, 162, 96, 35, 179, 105, 227, 72, 33, + 97, 20, 46, 10, 151, 133, 163, 66, 50, 192, 4, 65, 1, 184, 73, 161, 192, 76, 34, 18, 102, + 97, 148, 105, 2, 176, 33, 160, 144, 48, 9, 55, 32, 64, 64, 50, 26, 18, 42, 82, 192, 64, + 202, 18, 96, 9, 5, 96, 146, 180, 48, 140, 54, 73, 148, 36, 141, 80, 64, 45, 65, 56, 8, 8, + 192, 81, 12, 35, 106, 34, 199, 44, 99, 198, 48, 128, 72, 138, 148, 64, 40, 28, 55, 77, 64, + 66, 108, 66, 144, 105, 164, 150, 108, 192, 64, 140, 16, 163, 8, 162, 16, 38, 68, 148, 69, + 163, 24, 48, 25, 131, 141, 2, 51, 81, 155, 16, 97, 72, 40, 8, 1, 39, 113, 154, 66, 1, 2, + 24, 12, 65, 2, 78, 139, 20, 76, 132, 150, 144, 34, 194, 1, 90, 166, 33, 64, 36, 48, 24, + 176, 140, 210, 128, 49, 2, 70, 140, 97, 200, 33, 204, 166, 133, 163, 8, 14, 220, 24, 48, + 18, 193, 48, 26, 33, 38, 130, 8, 70, 155, 8, 1, 8, 193, 108, 12, 192, 65, 130, 176, 36, 74, + 128, 65, 211, 176, 1, 27, 184, 36, 161, 164, 64, 196, 164, 5, 3, 38, 45, 161, 72, 136, 11, + 132, 65, 76, 48, 49, 16, 8, 145, 28, 41, 44, 67, 192, 96, 1, 150, 69, 196, 176, 77, 32, 68, + 104, 84, 16, 68, 219, 34, 18, 155, 162, 36, 202, 72, 129, 32, 184, 76, 155, 162, 101, 11, + 67, 5, 12, 136, 73, 35, 5, 96, 8, 20, 17, 32, 4, 129, 147, 18, 13, 96, 68, 110, 208, 0, 82, + 35, 41, 49, 25, 49, 68, 17, 165, 69, 0, 8, 105, 4, 169, 13, 160, 40, 44, 153, 166, 100, + 145, 178, 133, 160, 54, 97, 97, 72, 45, 161, 4, 65, 24, 24, 42, 25, 25, 133, 81, 64, 74, + 83, 0, 105, 138, 22, 128, 144, 4, 102, 9, 40, 146, 26, 19, 97, 98, 146, 9, 36, 8, 14, 163, + 182, 32, 89, 70, 96, 220, 56, 105, 137, 146, 5, 28, 57, 100, 193, 152, 12, 68, 136, 144, + 160, 128, 32, 28, 148, 132, 1, 73, 37, 84, 130, 1, 145, 72, 46, 194, 148, 41, 10, 32, 108, + 28, 5, 64, 88, 22, 101, 72, 136, 40, 132, 18, 132, 25, 34, 42, 74, 192, 4, 140, 180, 96, + 154, 18, 129, 27, 146, 69, 73, 40, 40, 20, 24, 44, 25, 194, 37, 193, 192, 133, 8, 33, 112, + 20, 66, 108, 18, 17, 100, 80, 38, 8, 202, 50, 109, 136, 56, 137, 33, 34, 128, 16, 131, 9, + 16, 163, 5, 32, 34, 44, 146, 196, 64, 196, 34, 65, 140, 4, 64, 18, 4, 9, 33, 178, 13, 225, + 56, 112, 219, 38, 129, 148, 64, 81, 227, 22, 16, 218, 152, 37, 160, 70, 73, 10, 23, 102, + 128, 8, 134, 155, 48, 96, 193, 72, 105, 147, 164, 105, 32, 24, 45, 17, 161, 65, 27, 34, 80, + 18, 71, 5, 1, 145, 33, 9, 169, 145, 20, 177, 33, 98, 8, 105, 100, 182, 64, 11, 136, 140, + 67, 128, 100, 2, 57, 82, 9, 72, 73, 33, 5, 108, 20, 195, 132, 16, 3, 82, 67, 22, 74, 220, + 150, 36, 26, 33, 41, 4, 136, 9, 160, 144, 144, 148, 8, 8, 18, 57, 14, 17, 145, 64, 227, 38, + 114, 216, 176, 97, 1, 35, 134, 16, 183, 108, 19, 1, 98, 10, 70, 144, 164, 196, 133, 153, 6, + 109, 75, 134, 96, 28, 144, 69, 212, 66, 101, 138, 148, 40, 8, 136, 113, 10, 34, 137, 75, + 52, 1, 11, 201, 16, 88, 162, 109, 65, 40, 133, 88, 20, 8, 28, 183, 76, 96, 144, 96, 193, + 194, 13, 195, 36, 114, 146, 82, 161, 19, 87, 104, 190, 86, 29, 20, 6, 250, 213, 237, 181, + 229, 34, 188, 98, 2, 15, 224, 202, 108, 158, 25, 109, 95, 80, 252, 12, 110, 238, 195, 190, + 252, 174, 173, 249, 31, 20, 173, 76, 174, 12, 72, 235, 108, 61, 41, 93, 186, 241, 45, 2, 9, + 211, 117, 73, 221, 65, 54, 57, 228, 17, 62, 242, 105, 6, 170, 72, 222, 227, 79, 38, 101, + 53, 142, 115, 237, 214, 18, 175, 86, 214, 247, 72, 114, 86, 229, 74, 151, 191, 61, 44, 78, + 239, 105, 159, 20, 179, 136, 131, 121, 41, 193, 162, 130, 222, 192, 210, 250, 148, 205, + 230, 0, 69, 100, 22, 226, 20, 46, 231, 105, 139, 158, 202, 92, 156, 46, 67, 213, 163, 169, + 224, 43, 12, 150, 113, 174, 234, 240, 7, 109, 128, 67, 181, 57, 215, 9, 115, 196, 199, 88, + 255, 179, 205, 139, 120, 254, 187, 206, 15, 229, 184, 151, 106, 192, 58, 106, 194, 55, 88, + 150, 77, 238, 26, 183, 64, 81, 245, 170, 230, 31, 129, 57, 75, 104, 30, 102, 239, 222, 22, + 200, 103, 188, 61, 235, 226, 167, 147, 149, 115, 18, 232, 214, 209, 184, 245, 163, 192, 47, + 195, 246, 209, 68, 117, 134, 77, 23, 247, 40, 150, 92, 123, 172, 89, 237, 19, 102, 37, 0, + 82, 67, 221, 157, 249, 236, 166, 40, 21, 72, 101, 196, 183, 203, 200, 21, 254, 109, 59, 95, + 128, 52, 167, 213, 101, 251, 185, 239, 171, 150, 86, 24, 120, 152, 100, 158, 13, 13, 70, + 107, 103, 179, 54, 89, 253, 250, 180, 75, 76, 58, 107, 186, 101, 232, 42, 135, 193, 216, + 87, 78, 75, 79, 141, 150, 49, 82, 11, 157, 127, 83, 208, 235, 250, 248, 158, 178, 251, 15, + 102, 8, 56, 53, 150, 6, 36, 111, 34, 11, 249, 47, 10, 233, 201, 85, 54, 241, 152, 27, 33, + 14, 197, 157, 226, 121, 235, 96, 130, 208, 98, 205, 196, 26, 162, 141, 220, 27, 40, 40, + 167, 60, 236, 23, 101, 113, 216, 217, 18, 254, 178, 44, 29, 115, 67, 41, 171, 247, 36, 237, + 33, 31, 184, 140, 130, 34, 197, 249, 103, 97, 199, 100, 192, 203, 105, 153, 86, 141, 213, + 111, 76, 118, 214, 20, 187, 129, 183, 241, 105, 134, 218, 212, 196, 56, 233, 247, 105, 239, + 171, 239, 33, 52, 218, 31, 51, 73, 106, 209, 135, 215, 222, 60, 139, 241, 241, 223, 66, + 150, 83, 145, 247, 51, 155, 96, 8, 134, 25, 187, 28, 233, 137, 102, 161, 237, 160, 172, + 233, 212, 49, 62, 233, 251, 98, 77, 219, 248, 56, 0, 17, 194, 151, 235, 98, 1, 68, 3, 249, + 162, 109, 7, 189, 142, 53, 2, 206, 225, 189, 201, 64, 85, 26, 131, 243, 182, 185, 4, 171, + 53, 97, 101, 52, 67, 170, 237, 67, 71, 251, 174, 223, 104, 204, 98, 35, 188, 149, 219, 253, + 124, 206, 186, 12, 198, 200, 112, 119, 138, 32, 233, 249, 35, 92, 223, 69, 138, 98, 178, + 42, 247, 206, 193, 191, 29, 206, 42, 145, 80, 91, 1, 142, 33, 168, 210, 78, 27, 178, 167, + 239, 253, 170, 16, 75, 73, 38, 255, 174, 109, 239, 226, 159, 92, 216, 13, 105, 137, 246, + 141, 45, 251, 223, 67, 132, 78, 220, 180, 90, 18, 112, 13, 63, 235, 172, 116, 105, 11, 220, + 200, 180, 99, 132, 162, 66, 171, 199, 94, 42, 179, 40, 58, 3, 154, 9, 163, 222, 57, 238, + 52, 54, 129, 114, 101, 222, 173, 91, 60, 77, 66, 88, 102, 152, 246, 30, 11, 237, 182, 37, + 45, 145, 228, 153, 245, 239, 123, 54, 6, 58, 166, 86, 110, 187, 31, 159, 32, 198, 39, 123, + 164, 49, 42, 227, 222, 0, 125, 236, 252, 134, 8, 20, 119, 59, 35, 176, 43, 29, 175, 232, + 182, 98, 240, 122, 247, 18, 244, 154, 70, 186, 201, 158, 91, 178, 52, 212, 245, 129, 172, + 235, 126, 175, 126, 165, 76, 253, 115, 89, 214, 61, 137, 62, 168, 244, 100, 170, 36, 105, + 31, 5, 140, 64, 197, 5, 243, 86, 222, 194, 64, 40, 194, 15, 1, 102, 64, 216, 118, 197, 202, + 97, 113, 193, 130, 177, 94, 231, 123, 71, 28, 220, 130, 28, 254, 211, 41, 84, 106, 47, 48, + 83, 122, 142, 168, 236, 95, 235, 33, 94, 236, 120, 176, 204, 215, 82, 110, 234, 92, 122, + 49, 135, 27, 34, 242, 187, 196, 209, 88, 39, 171, 122, 251, 117, 234, 122, 125, 196, 193, + 196, 41, 169, 171, 42, 144, 39, 208, 145, 169, 95, 118, 15, 204, 94, 74, 104, 219, 180, + 231, 84, 29, 172, 42, 30, 222, 232, 64, 115, 84, 90, 169, 2, 4, 119, 204, 220, 252, 219, + 30, 91, 2, 49, 91, 181, 154, 224, 82, 136, 219, 251, 110, 73, 133, 87, 195, 64, 196, 42, + 124, 169, 243, 125, 122, 153, 18, 153, 49, 244, 36, 236, 69, 195, 221, 16, 223, 250, 146, + 214, 128, 198, 110, 53, 199, 223, 23, 25, 171, 240, 147, 27, 21, 237, 103, 131, 3, 113, + 161, 207, 85, 127, 152, 181, 175, 22, 163, 41, 10, 97, 164, 222, 1, 146, 236, 6, 234, 236, + 0, 118, 161, 232, 41, 234, 157, 185, 108, 12, 179, 133, 217, 199, 238, 125, 211, 95, 6, + 204, 89, 159, 100, 0, 218, 231, 86, 219, 53, 74, 46, 47, 247, 57, 211, 53, 172, 95, 111, + 214, 171, 184, 4, 163, 244, 232, 213, 58, 202, 35, 228, 187, 125, 125, 7, 235, 255, 91, + 169, 180, 201, 248, 85, 244, 177, 211, 32, 248, 39, 75, 220, 195, 130, 252, 205, 75, 153, + 97, 17, 111, 111, 52, 253, 127, 60, 230, 219, 200, 76, 46, 80, 172, 233, 236, 144, 103, + 150, 198, 69, 234, 215, 240, 155, 104, 4, 141, 247, 200, 220, 207, 254, 132, 199, 248, 24, + 23, 51, 63, 126, 237, 114, 199, 213, 139, 187, 40, 27, 123, 241, 191, 19, 200, 210, 91, + 176, 12, 143, 178, 108, 110, 62, 131, 61, 101, 226, 30, 213, 172, 246, 27, 236, 212, 101, + 185, 54, 227, 213, 198, 112, 224, 9, 86, 49, 13, 184, 79, 248, 87, 158, 68, 178, 187, 45, + 120, 95, 71, 77, 5, 49, 58, 123, 61, 165, 240, 129, 221, 62, 172, 12, 27, 224, 201, 193, + 125, 84, 89, 176, 149, 69, 92, 55, 215, 116, 246, 119, 99, 126, 144, 125, 165, 210, 94, 75, + 165, 48, 241, 74, 148, 87, 39, 154, 105, 226, 105, 11, 41, 36, 154, 36, 210, 85, 156, 5, + 166, 52, 107, 219, 162, 246, 221, 207, 161, 180, 154, 180, 119, 128, 162, 222, 206, 180, + 189, 66, 88, 116, 114, 94, 251, 152, 72, 80, 76, 210, 182, 14, 135, 105, 99, 161, 206, 202, + 140, 37, 211, 225, 45, 51, 240, 241, 64, 53, 231, 162, 26, 124, 7, 163, 71, 163, 151, 100, + 25, 183, 201, 95, 53, 233, 16, 217, 69, 129, 103, 10, 190, 51, 212, 168, 221, 105, 29, 228, + 212, 203, 157, 117, 49, 108, 201, 185, 153, 112, 134, 27, 115, 160, 103, 226, 218, 248, + 107, 217, 15, 74, 171, 171, 208, 208, 7, 183, 202, 27, 71, 253, 186, 76, 84, 138, 220, 56, + 227, 241, 14, 19, 150, 196, 124, 148, 129, 20, 65, 126, 17, 185, 243, 134, 138, 242, 105, + 90, 248, 212, 103, 14, 143, 46, 231, 227, 219, 235, 77, 124, 189, 116, 2, 17, 165, 92, 78, + 242, 184, 45, 204, 249, 145, 87, 180, 39, 157, 13, 246, 149, 83, 102, 25, 125, 121, 127, + 242, 47, 122, 216, 64, 9, 224, 42, 14, 68, 217, 206, 29, 154, 154, 185, 71, 93, 32, 192, + 35, 96, 124, 14, 37, 39, 239, 198, 41, 0, 81, 200, 111, 133, 38, 108, 224, 159, 34, 231, + 219, 172, 66, 77, 208, 194, 73, 221, 179, 26, 117, 4, 17, 144, 193, 111, 195, 106, 236, + 205, 155, 47, 172, 117, 4, 120, 187, 149, 8, 60, 97, 217, 96, 24, 168, 108, 185, 9, 255, + 177, 221, 1, 101, 213, 173, 138, 42, 16, 206, 13, 17, 82, 54, 147, 167, 151, 94, 69, 98, + 132, 162, 51, 176, 197, 51, 208, 199, 142, 148, 186, 80, 217, 141, 69, 126, 46, 122, 103, + 205, 161, 104, 194, 149, 5, 68, 135, 100, 226, 151, 135, 60, 207, 169, 178, 142, 35, 187, + 96, 193, 117, 116, 247, 176, 156, 215, 247, 208, 47, 44, 194, 93, 142, 95, 221, 215, 208, + 135, 147, 168, 229, 31, 3, 8, 104, 32, 70, 113, 231, 219, 167, 47, 65, 228, 128, 72, 68, + 149, 63, 102, 65, 188, 43, 75, 8, 144, 210, 3, 190, 168, 209, 31, 79, 153, 72, 3, 137, 78, + 145, 127, 72, 90, 243, 96, 187, 91, 181, 19, 31, 95, 167, 38, 190, 157, 2, 84, 52, 199, + 239, 27, 191, 140, 6, 242, 1, 5, 44, 226, 249, 113, 139, 224, 104, 165, 118, 5, 223, 49, + 95, 205, 181, 242, 180, 150, 156, 50, 109, 20, 27, 238, 24, 135, 34, 217, 82, 68, 111, 41, + 81, 131, 61, 187, 230, 98, 34, 116, 248, 98, 7, 178, 145, 154, 178, 177, 235, 88, 175, 36, + 73, 139, 109, 210, 239, 127, 12, 199, 219, 209, 242, 222, 23, 249, 79, 76, 137, 133, 135, + 22, 164, 254, 232, 179, 178, 141, 242, 159, 119, 218, 164, 8, 61, 138, 227, 97, 215, 22, + 67, 11, 186, 48, 38, 81, 187, 7, 102, 73, 222, 61, 120, 188, 206, 117, 92, 210, 233, 191, + 72, 233, 180, 30, 151, 42, 25, 86, 0, 126, 184, 55, 241, 75, 148, 239, 108, 233, 141, 127, + 176, 228, 57, + ]; + let expected_pk_bytes = [ + 80, 31, 193, 46, 100, 86, 79, 62, 184, 160, 173, 26, 122, 204, 110, 125, 224, 72, 30, 57, + 97, 119, 139, 57, 40, 194, 81, 43, 190, 78, 129, 42, 210, 95, 207, 37, 221, 194, 81, 173, + 155, 15, 239, 55, 163, 196, 8, 55, 194, 25, 27, 219, 58, 26, 80, 216, 224, 134, 116, 13, + 127, 199, 195, 223, 52, 249, 143, 220, 116, 183, 246, 51, 218, 185, 66, 107, 146, 82, 48, + 35, 227, 40, 141, 108, 204, 155, 144, 91, 153, 223, 216, 31, 116, 87, 15, 12, 16, 78, 14, + 96, 211, 154, 9, 100, 203, 138, 81, 146, 63, 220, 173, 231, 28, 137, 250, 160, 77, 189, + 161, 226, 60, 150, 193, 162, 181, 155, 39, 104, 88, 2, 202, 126, 105, 14, 220, 39, 212, 71, + 163, 188, 204, 91, 203, 46, 119, 218, 248, 95, 33, 189, 138, 93, 34, 132, 56, 250, 182, + 247, 195, 205, 199, 217, 192, 241, 29, 161, 107, 138, 155, 36, 145, 165, 99, 116, 201, 223, + 30, 221, 5, 24, 197, 156, 111, 5, 173, 78, 158, 79, 22, 199, 73, 237, 108, 174, 135, 222, + 226, 1, 213, 211, 152, 113, 30, 109, 92, 58, 234, 168, 220, 11, 195, 212, 150, 93, 192, + 200, 39, 7, 25, 254, 238, 165, 139, 223, 54, 7, 177, 170, 222, 57, 12, 8, 163, 149, 180, + 169, 202, 171, 90, 33, 240, 18, 7, 9, 57, 233, 33, 97, 176, 84, 115, 117, 43, 92, 219, 182, + 13, 133, 151, 63, 185, 204, 206, 159, 34, 126, 168, 44, 24, 126, 189, 169, 189, 195, 172, + 99, 234, 84, 142, 21, 154, 94, 211, 125, 54, 94, 12, 195, 74, 78, 124, 251, 133, 217, 124, + 70, 55, 190, 87, 250, 229, 2, 205, 22, 53, 67, 182, 175, 10, 56, 250, 162, 106, 13, 168, 9, + 175, 196, 178, 67, 30, 139, 108, 59, 53, 52, 171, 126, 101, 119, 158, 253, 16, 149, 185, + 45, 118, 220, 68, 139, 130, 255, 174, 122, 232, 78, 163, 213, 167, 241, 22, 151, 236, 83, + 96, 205, 204, 54, 152, 5, 56, 249, 188, 80, 40, 126, 143, 249, 214, 6, 197, 74, 215, 93, + 180, 249, 168, 248, 247, 250, 203, 28, 156, 7, 9, 193, 235, 10, 202, 150, 98, 154, 62, 108, + 236, 203, 209, 184, 51, 225, 171, 228, 230, 5, 48, 124, 252, 115, 51, 8, 159, 8, 91, 120, + 11, 126, 88, 171, 152, 175, 8, 60, 14, 157, 169, 188, 133, 72, 6, 28, 236, 73, 138, 90, 91, + 141, 213, 121, 0, 201, 86, 0, 66, 218, 195, 176, 73, 159, 102, 22, 224, 150, 128, 161, 254, + 80, 83, 248, 62, 8, 175, 241, 2, 99, 63, 10, 48, 188, 15, 104, 196, 157, 38, 10, 54, 161, + 250, 150, 47, 62, 33, 26, 17, 252, 210, 52, 130, 69, 113, 117, 139, 82, 89, 22, 18, 222, + 19, 157, 90, 254, 88, 246, 179, 55, 228, 60, 113, 178, 46, 41, 148, 47, 52, 10, 91, 27, 26, + 186, 2, 52, 251, 87, 142, 39, 74, 2, 68, 184, 216, 135, 55, 229, 130, 160, 86, 95, 222, + 196, 86, 130, 90, 215, 131, 143, 130, 226, 226, 1, 132, 225, 178, 137, 49, 220, 245, 125, + 205, 91, 4, 25, 112, 201, 160, 97, 121, 171, 154, 193, 145, 33, 112, 95, 70, 246, 249, 156, + 255, 159, 89, 206, 129, 101, 97, 253, 16, 83, 64, 122, 74, 253, 96, 52, 208, 217, 171, 38, + 209, 234, 74, 192, 60, 39, 140, 91, 102, 147, 111, 229, 12, 43, 162, 11, 159, 156, 26, 170, + 185, 106, 223, 84, 70, 75, 217, 179, 223, 90, 64, 49, 253, 47, 243, 38, 248, 173, 230, 40, + 238, 180, 13, 223, 19, 70, 48, 22, 61, 30, 140, 223, 200, 110, 63, 13, 242, 88, 195, 170, + 30, 140, 0, 169, 178, 95, 152, 39, 234, 111, 146, 1, 44, 7, 215, 229, 120, 219, 2, 238, 18, + 253, 32, 12, 128, 91, 49, 119, 185, 99, 132, 133, 79, 74, 8, 121, 169, 170, 191, 158, 125, + 170, 127, 84, 154, 22, 187, 36, 17, 181, 245, 211, 34, 241, 235, 153, 170, 109, 36, 204, 2, + 229, 219, 129, 245, 242, 41, 179, 189, 224, 67, 63, 67, 223, 155, 161, 228, 147, 73, 122, + 247, 191, 153, 249, 47, 160, 41, 118, 2, 237, 128, 75, 255, 15, 68, 224, 83, 157, 11, 163, + 11, 94, 186, 130, 208, 203, 176, 131, 71, 187, 38, 251, 41, 91, 167, 250, 159, 150, 74, 16, + 92, 39, 76, 49, 18, 127, 122, 254, 245, 165, 107, 45, 107, 28, 195, 121, 166, 103, 249, 80, + 90, 61, 197, 63, 70, 186, 51, 229, 244, 43, 14, 82, 243, 186, 220, 63, 242, 141, 30, 84, + 92, 163, 74, 64, 39, 234, 16, 204, 204, 156, 74, 104, 182, 204, 134, 16, 121, 38, 187, 175, + 244, 238, 25, 123, 33, 33, 179, 79, 97, 187, 137, 102, 198, 144, 109, 233, 140, 206, 30, + 82, 99, 44, 56, 107, 123, 175, 76, 88, 203, 27, 252, 231, 190, 100, 13, 160, 182, 243, 52, + 211, 116, 80, 66, 8, 12, 59, 66, 30, 145, 21, 80, 208, 31, 107, 57, 107, 204, 115, 159, + 196, 159, 112, 103, 43, 55, 160, 157, 167, 42, 110, 174, 17, 84, 241, 149, 35, 55, 213, 98, + 198, 185, 241, 4, 17, 86, 174, 71, 141, 44, 129, 25, 141, 211, 92, 79, 11, 201, 80, 243, + 243, 15, 168, 165, 179, 134, 180, 22, 114, 220, 163, 163, 244, 37, 19, 79, 22, 113, 208, + 94, 53, 95, 243, 49, 119, 188, 171, 7, 152, 122, 162, 56, 210, 186, 131, 250, 230, 139, 31, + 34, 105, 13, 139, 22, 132, 49, 181, 166, 115, 188, 210, 50, 31, 147, 130, 150, 237, 89, 96, + 131, 48, 188, 100, 122, 53, 227, 83, 181, 18, 83, 73, 66, 23, 71, 25, 100, 65, 32, 229, + 173, 29, 139, 180, 88, 209, 72, 104, 43, 136, 228, 105, 30, 217, 164, 195, 242, 20, 146, + 218, 211, 193, 166, 137, 170, 132, 66, 213, 36, 45, 185, 245, 248, 182, 144, 164, 228, 15, + 108, 229, 87, 139, 211, 59, 249, 106, 237, 210, 134, 135, 99, 83, 218, 61, 123, 245, 145, + 123, 79, 37, 56, 234, 216, 103, 183, 182, 233, 251, 214, 235, 161, 64, 31, 100, 206, 172, + 171, 230, 9, 27, 10, 211, 4, 201, 40, 146, 10, 120, 82, 203, 41, 171, 143, 239, 90, 138, + 160, 159, 95, 240, 111, 152, 252, 13, 194, 151, 37, 102, 239, 100, 80, 106, 13, 102, 127, + 3, 132, 78, 180, 130, 23, 137, 36, 188, 202, 120, 124, 19, 6, 101, 89, 105, 135, 246, 217, + 105, 221, 153, 231, 116, 80, 50, 104, 2, 100, 64, 28, 14, 42, 172, 150, 161, 161, 114, 73, + 221, 12, 160, 54, 97, 59, 115, 110, 191, 82, 93, 75, 158, 63, 47, 123, 27, 247, 250, 114, + 128, 87, 1, 153, 234, 27, 89, 32, 161, 91, 229, 62, 203, 59, 173, 183, 189, 177, 21, 142, + 86, 95, 40, 100, 141, 228, 67, 228, 197, 7, 110, 152, 240, 15, 38, 28, 138, 158, 148, 177, + 249, 202, 137, 166, 16, 253, 22, 187, 111, 167, 205, 90, 245, 185, 155, 30, 228, 9, 43, 77, + 34, 6, 83, 100, 22, 175, 37, 12, 31, 190, 165, 61, 168, 6, 70, 134, 101, 17, 42, 12, 2, + 171, 106, 55, 191, 22, 62, 110, 235, 223, 198, 22, 226, 224, 193, 45, 52, 177, 50, 152, + 185, 95, 206, 75, 160, 201, 185, 92, 205, 249, 177, 6, 140, 67, 114, 61, 138, 67, 29, 208, + 210, 65, 240, + ]; + let expected_sig_bytes = [ + 222, 63, 171, 20, 147, 118, 203, 86, 51, 247, 124, 37, 241, 113, 173, 203, 0, 229, 25, 156, + 160, 58, 251, 220, 43, 152, 249, 166, 227, 12, 232, 239, 238, 10, 245, 197, 93, 4, 109, 31, + 60, 106, 11, 173, 42, 31, 244, 226, 76, 237, 142, 91, 124, 22, 66, 2, 203, 205, 15, 146, + 204, 216, 103, 57, 43, 42, 217, 127, 199, 35, 47, 160, 217, 62, 120, 212, 37, 58, 136, 191, + 50, 237, 2, 243, 187, 133, 64, 96, 179, 37, 150, 72, 118, 73, 225, 206, 181, 250, 36, 207, + 39, 215, 161, 164, 235, 153, 43, 137, 194, 228, 238, 68, 217, 104, 37, 117, 252, 15, 206, + 116, 9, 160, 54, 166, 87, 195, 180, 181, 55, 73, 19, 201, 229, 101, 171, 174, 100, 12, 166, + 163, 72, 71, 205, 92, 55, 165, 101, 160, 6, 25, 178, 225, 92, 55, 125, 32, 222, 223, 153, + 103, 245, 153, 156, 226, 140, 85, 147, 30, 107, 167, 216, 133, 156, 21, 84, 120, 0, 193, + 130, 230, 24, 101, 113, 1, 86, 13, 171, 48, 183, 184, 214, 251, 128, 57, 232, 71, 169, 127, + 232, 23, 17, 239, 199, 58, 69, 11, 12, 0, 77, 252, 51, 216, 5, 118, 42, 230, 121, 0, 94, + 31, 174, 203, 96, 197, 199, 76, 247, 70, 35, 67, 162, 58, 58, 241, 197, 48, 188, 174, 13, + 146, 164, 102, 96, 124, 52, 213, 127, 102, 104, 221, 107, 54, 21, 242, 171, 35, 130, 16, + 89, 56, 90, 163, 203, 146, 16, 236, 129, 197, 1, 129, 134, 36, 189, 95, 124, 72, 187, 0, + 123, 195, 112, 218, 211, 37, 245, 148, 45, 70, 26, 5, 224, 104, 64, 254, 106, 28, 74, 133, + 147, 137, 81, 198, 93, 68, 85, 1, 230, 248, 166, 238, 211, 182, 59, 36, 3, 241, 64, 99, + 250, 37, 7, 92, 50, 55, 157, 175, 101, 20, 25, 65, 233, 186, 9, 182, 233, 186, 63, 100, 65, + 40, 231, 177, 105, 118, 241, 244, 249, 153, 174, 22, 147, 206, 142, 140, 219, 38, 36, 196, + 35, 210, 222, 139, 42, 86, 46, 161, 136, 193, 237, 115, 217, 113, 191, 165, 254, 80, 175, + 54, 217, 236, 209, 188, 151, 193, 184, 181, 70, 61, 173, 186, 204, 103, 144, 191, 1, 73, + 80, 244, 205, 87, 57, 79, 175, 250, 124, 230, 190, 57, 122, 249, 233, 194, 88, 60, 97, 50, + 231, 184, 105, 198, 188, 242, 186, 145, 228, 201, 8, 133, 127, 116, 150, 7, 205, 154, 94, + 163, 175, 246, 59, 23, 34, 208, 59, 102, 185, 194, 190, 52, 80, 216, 186, 35, 17, 108, 207, + 183, 174, 174, 164, 142, 115, 182, 136, 240, 16, 253, 188, 40, 108, 54, 245, 46, 167, 108, + 22, 197, 58, 104, 170, 109, 200, 152, 116, 174, 81, 238, 187, 16, 240, 107, 25, 159, 238, + 190, 186, 152, 86, 165, 38, 19, 51, 44, 44, 173, 93, 38, 77, 193, 46, 64, 34, 131, 245, + 235, 245, 109, 254, 171, 135, 146, 139, 151, 201, 11, 61, 189, 195, 52, 81, 70, 33, 231, + 109, 113, 98, 221, 173, 107, 235, 163, 171, 102, 65, 251, 132, 95, 249, 207, 116, 54, 78, + 54, 29, 95, 224, 147, 157, 42, 31, 19, 66, 117, 206, 220, 207, 217, 142, 61, 126, 113, 93, + 196, 225, 189, 237, 42, 134, 153, 205, 66, 198, 5, 114, 47, 37, 223, 215, 67, 158, 194, + 225, 155, 208, 176, 153, 138, 192, 89, 162, 163, 112, 125, 87, 114, 171, 57, 221, 195, 129, + 241, 51, 202, 59, 142, 175, 112, 128, 140, 173, 196, 206, 240, 225, 88, 87, 162, 199, 163, + 77, 64, 235, 115, 113, 83, 243, 0, 40, 148, 80, 51, 80, 254, 20, 203, 148, 0, 238, 73, 156, + 5, 3, 233, 19, 212, 15, 129, 175, 96, 71, 114, 136, 203, 242, 155, 255, 31, 132, 14, 111, + 4, 37, 71, 146, 210, 185, 143, 252, 174, 222, 252, 124, 39, 192, 206, 132, 1, 220, 216, + 208, 38, 112, 239, 86, 145, 59, 238, 73, 171, 64, 17, 211, 42, 108, 160, 163, 27, 235, 183, + 93, 201, 145, 225, 192, 27, 159, 62, 126, 56, 173, 227, 116, 233, 253, 165, 15, 28, 48, + 184, 239, 134, 161, 239, 228, 167, 198, 77, 75, 11, 60, 133, 117, 155, 36, 208, 133, 67, + 219, 86, 87, 84, 52, 198, 84, 193, 26, 72, 213, 11, 46, 254, 1, 122, 149, 37, 69, 195, 54, + 242, 67, 163, 183, 60, 136, 63, 106, 2, 148, 207, 212, 51, 15, 196, 0, 227, 31, 175, 18, + 231, 88, 65, 187, 165, 9, 172, 35, 28, 15, 185, 103, 49, 244, 216, 81, 3, 247, 226, 28, + 230, 79, 244, 85, 21, 14, 62, 48, 143, 156, 15, 65, 81, 185, 24, 41, 222, 120, 85, 200, + 130, 229, 102, 49, 92, 172, 89, 18, 13, 130, 252, 198, 45, 174, 2, 16, 173, 173, 170, 152, + 154, 72, 65, 21, 255, 183, 253, 33, 54, 159, 218, 231, 28, 163, 5, 106, 188, 255, 164, 121, + 116, 60, 13, 85, 217, 51, 18, 130, 233, 124, 8, 130, 72, 153, 235, 169, 95, 12, 154, 128, + 40, 242, 221, 158, 226, 47, 241, 151, 76, 66, 144, 43, 142, 88, 213, 204, 84, 56, 30, 21, + 64, 179, 28, 53, 233, 238, 60, 214, 79, 242, 221, 189, 83, 112, 192, 235, 113, 249, 54, + 108, 216, 37, 242, 98, 242, 79, 233, 123, 253, 245, 246, 110, 146, 28, 194, 67, 175, 65, + 40, 169, 98, 97, 50, 131, 229, 79, 104, 208, 143, 3, 252, 33, 177, 233, 20, 171, 181, 117, + 206, 210, 147, 140, 86, 229, 158, 181, 14, 185, 31, 242, 49, 190, 190, 213, 58, 237, 208, + 10, 106, 3, 129, 50, 251, 230, 54, 39, 245, 213, 144, 78, 15, 99, 61, 31, 231, 115, 154, + 195, 85, 114, 215, 140, 44, 157, 20, 29, 33, 77, 160, 205, 11, 134, 131, 19, 123, 68, 28, + 76, 245, 90, 63, 97, 192, 99, 13, 112, 59, 228, 159, 147, 210, 221, 132, 22, 144, 54, 1, + 109, 95, 27, 76, 210, 3, 201, 245, 221, 33, 211, 116, 13, 251, 238, 192, 150, 187, 249, + 136, 0, 10, 44, 209, 79, 241, 49, 158, 136, 112, 165, 42, 5, 1, 251, 46, 73, 38, 252, 133, + 108, 7, 229, 220, 74, 159, 217, 215, 195, 63, 160, 189, 51, 192, 194, 2, 220, 240, 192, + 236, 42, 39, 193, 205, 81, 64, 87, 150, 108, 25, 26, 43, 245, 238, 166, 25, 10, 255, 80, + 223, 245, 139, 252, 236, 7, 144, 64, 105, 237, 254, 12, 165, 188, 74, 123, 61, 88, 40, 106, + 148, 56, 120, 123, 197, 164, 70, 231, 185, 132, 65, 62, 61, 24, 92, 8, 1, 62, 54, 43, 156, + 92, 95, 138, 50, 245, 101, 219, 236, 163, 185, 13, 30, 8, 248, 58, 19, 86, 42, 184, 26, 25, + 126, 184, 146, 38, 198, 204, 160, 225, 144, 194, 82, 37, 25, 36, 199, 5, 214, 181, 177, + 160, 48, 73, 180, 110, 149, 146, 130, 100, 72, 30, 20, 180, 231, 30, 124, 20, 118, 1, 51, + 63, 208, 237, 182, 190, 210, 231, 48, 8, 133, 214, 92, 72, 107, 240, 4, 43, 217, 35, 96, 0, + 176, 237, 12, 0, 143, 108, 55, 168, 171, 2, 52, 115, 153, 22, 94, 7, 171, 136, 85, 20, 127, + 79, 118, 208, 27, 154, 40, 244, 3, 179, 107, 177, 188, 162, 27, 98, 109, 153, 216, 185, 6, + 112, 81, 154, 118, 27, 4, 209, 175, 140, 202, 246, 216, 209, 118, 215, 145, 163, 128, 125, + 163, 60, 4, 128, 203, 64, 209, 247, 36, 116, 203, 19, 208, 123, 215, 84, 235, 2, 201, 93, + 25, 187, 71, 151, 182, 116, 180, 240, 123, 188, 53, 61, 70, 19, 45, 58, 62, 182, 44, 56, + 146, 212, 173, 1, 3, 33, 141, 162, 140, 22, 116, 87, 143, 107, 127, 226, 183, 218, 68, 176, + 226, 235, 244, 231, 55, 54, 223, 159, 177, 37, 211, 135, 35, 247, 252, 249, 159, 212, 44, + 98, 220, 11, 84, 60, 158, 1, 216, 242, 139, 189, 206, 136, 120, 127, 8, 66, 146, 108, 60, + 193, 6, 83, 29, 143, 143, 234, 12, 136, 75, 239, 162, 231, 247, 30, 120, 102, 33, 152, 3, + 253, 146, 161, 50, 225, 39, 110, 6, 4, 144, 253, 74, 199, 33, 42, 189, 247, 138, 12, 68, + 179, 161, 131, 117, 144, 33, 100, 116, 238, 243, 10, 97, 118, 208, 154, 113, 203, 189, 171, + 15, 4, 130, 8, 126, 25, 219, 111, 60, 59, 75, 107, 115, 49, 134, 228, 45, 14, 107, 131, 80, + 43, 166, 87, 100, 198, 96, 39, 118, 101, 145, 79, 117, 235, 213, 227, 117, 64, 193, 207, + 104, 127, 5, 57, 30, 231, 33, 8, 210, 156, 84, 143, 78, 22, 250, 138, 53, 242, 84, 23, 209, + 75, 52, 111, 191, 165, 142, 151, 193, 157, 117, 5, 247, 160, 30, 247, 141, 102, 46, 133, + 198, 231, 251, 112, 85, 251, 25, 160, 85, 124, 5, 76, 209, 1, 225, 38, 14, 211, 9, 160, 76, + 208, 72, 54, 192, 126, 241, 144, 65, 209, 48, 64, 86, 141, 142, 5, 160, 78, 1, 96, 172, + 234, 232, 53, 22, 93, 21, 208, 88, 30, 243, 35, 109, 108, 86, 102, 126, 145, 218, 120, 172, + 129, 156, 63, 192, 213, 220, 154, 59, 166, 168, 178, 16, 31, 191, 12, 80, 189, 54, 251, 11, + 98, 132, 11, 88, 229, 20, 204, 97, 190, 48, 111, 154, 149, 125, 214, 163, 57, 255, 62, 88, + 60, 212, 110, 126, 14, 175, 6, 215, 119, 30, 171, 26, 4, 68, 79, 122, 46, 8, 56, 94, 175, + 167, 97, 220, 160, 40, 126, 165, 157, 176, 94, 17, 120, 250, 92, 120, 178, 196, 203, 77, + 26, 194, 34, 76, 232, 147, 108, 195, 206, 120, 232, 143, 58, 224, 126, 213, 89, 248, 200, + 86, 234, 33, 178, 72, 67, 71, 185, 99, 193, 100, 149, 203, 230, 197, 159, 99, 145, 130, + 156, 214, 180, 175, 140, 190, 163, 59, 168, 101, 154, 206, 15, 24, 103, 163, 7, 137, 33, + 191, 13, 244, 150, 123, 178, 129, 134, 188, 192, 188, 215, 115, 82, 52, 49, 118, 219, 4, + 10, 5, 227, 240, 123, 187, 26, 227, 86, 175, 36, 88, 92, 118, 193, 2, 223, 76, 70, 159, 30, + 93, 117, 126, 217, 99, 156, 193, 177, 149, 161, 201, 84, 177, 181, 25, 97, 117, 193, 137, + 153, 68, 228, 181, 195, 94, 223, 247, 224, 183, 65, 150, 148, 125, 179, 94, 227, 177, 204, + 142, 41, 183, 130, 169, 157, 217, 213, 128, 174, 53, 235, 63, 159, 247, 128, 147, 242, 28, + 129, 29, 125, 142, 250, 220, 150, 5, 154, 90, 158, 189, 12, 33, 183, 103, 240, 80, 181, + 196, 244, 119, 224, 64, 246, 95, 2, 252, 140, 135, 30, 72, 180, 137, 143, 220, 189, 52, + 110, 88, 126, 243, 107, 183, 204, 139, 246, 18, 174, 46, 85, 232, 94, 82, 36, 181, 195, + 105, 114, 142, 204, 117, 18, 93, 220, 181, 59, 195, 195, 192, 172, 82, 222, 70, 240, 219, + 37, 113, 146, 76, 58, 34, 169, 105, 230, 19, 106, 135, 101, 229, 28, 227, 176, 11, 94, 16, + 112, 19, 111, 177, 213, 93, 25, 145, 76, 83, 172, 172, 110, 62, 110, 18, 181, 87, 65, 201, + 48, 81, 78, 120, 168, 142, 16, 106, 119, 1, 106, 93, 61, 62, 198, 75, 130, 71, 32, 156, + 245, 43, 219, 80, 13, 199, 208, 168, 41, 249, 84, 113, 24, 37, 97, 121, 28, 147, 215, 77, + 246, 141, 28, 143, 228, 35, 17, 175, 112, 202, 167, 246, 138, 203, 212, 24, 20, 245, 23, + 39, 80, 81, 122, 245, 197, 211, 53, 19, 99, 179, 138, 149, 106, 128, 201, 0, 31, 164, 121, + 72, 2, 7, 105, 244, 202, 6, 170, 45, 98, 229, 93, 36, 233, 237, 95, 235, 91, 240, 103, 181, + 54, 40, 136, 5, 63, 89, 146, 145, 150, 175, 16, 125, 226, 3, 126, 66, 46, 210, 11, 123, + 195, 232, 71, 14, 16, 120, 16, 225, 166, 42, 220, 40, 95, 219, 154, 110, 111, 159, 54, 239, + 24, 196, 25, 173, 204, 59, 200, 58, 131, 195, 26, 248, 184, 177, 183, 233, 52, 38, 139, + 158, 135, 131, 80, 227, 11, 51, 171, 187, 191, 239, 252, 189, 88, 55, 191, 75, 33, 218, + 245, 143, 112, 155, 197, 165, 42, 210, 201, 150, 177, 202, 165, 248, 249, 57, 31, 57, 219, + 117, 172, 86, 2, 163, 67, 188, 15, 164, 201, 119, 14, 38, 239, 123, 144, 40, 92, 11, 25, + 237, 20, 122, 163, 63, 233, 42, 158, 113, 188, 245, 209, 210, 125, 172, 82, 212, 216, 89, + 104, 132, 240, 254, 242, 92, 187, 238, 124, 193, 217, 109, 92, 132, 219, 238, 103, 149, + 130, 117, 139, 219, 97, 49, 148, 69, 212, 216, 125, 78, 228, 19, 241, 140, 117, 54, 164, + 197, 82, 47, 243, 95, 244, 139, 78, 224, 218, 96, 199, 247, 230, 249, 75, 114, 168, 188, + 214, 32, 79, 92, 255, 85, 184, 18, 45, 129, 3, 50, 144, 183, 66, 62, 46, 69, 44, 62, 82, + 155, 92, 237, 150, 11, 47, 64, 62, 95, 35, 8, 228, 160, 191, 77, 82, 175, 56, 88, 189, 224, + 199, 89, 135, 177, 117, 155, 14, 100, 133, 88, 3, 124, 39, 77, 129, 220, 251, 110, 238, + 226, 136, 43, 170, 26, 199, 31, 212, 150, 146, 136, 254, 209, 131, 144, 213, 115, 139, 87, + 104, 31, 171, 109, 29, 75, 232, 200, 17, 79, 29, 31, 35, 45, 75, 104, 114, 124, 125, 156, + 160, 167, 227, 228, 234, 239, 52, 53, 83, 94, 124, 132, 141, 160, 168, 170, 183, 225, 231, + 3, 15, 29, 37, 50, 71, 77, 108, 135, 145, 172, 186, 236, 245, 253, 6, 11, 42, 47, 49, 90, + 111, 131, 133, 156, 162, 165, 186, 187, 208, 237, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 16, 29, 44, 60, + ]; + assert!(check( + &message, + &sk_bytes, + &expected_pk_bytes, + &expected_sig_bytes + )); + + let message = [ + 134, 63, 117, 183, 85, 147, 65, 64, 183, 62, 128, 121, 173, 222, 39, 113, 93, 217, 225, + 116, 57, 161, 128, 164, 160, 244, 32, 152, 201, 198, 97, 204, 85, 158, 45, 182, 221, 249, + 13, 246, 82, 131, 242, 54, 189, 126, 217, 51, 218, 11, 82, 8, 69, 122, 172, 87, 154, 194, + 79, + ]; + let sk_bytes = [ + 172, 57, 21, 137, 106, 84, 92, 210, 84, 135, 208, 132, 1, 214, 3, 201, 203, 177, 43, 37, + 17, 117, 184, 150, 68, 214, 89, 217, 62, 177, 164, 233, 122, 203, 51, 36, 27, 34, 35, 119, + 93, 62, 141, 31, 65, 68, 209, 134, 42, 214, 204, 197, 128, 54, 53, 170, 181, 163, 201, 210, + 141, 18, 236, 207, 86, 117, 182, 30, 128, 238, 27, 120, 128, 39, 206, 73, 117, 18, 6, 62, + 220, 96, 102, 243, 74, 73, 239, 251, 225, 40, 27, 231, 116, 27, 1, 249, 204, 146, 32, 24, + 49, 74, 34, 6, 82, 193, 194, 140, 32, 17, 74, 34, 51, 49, 218, 8, 141, 192, 150, 4, 18, 54, + 133, 25, 163, 141, 156, 200, 13, 90, 18, 50, 34, 167, 141, 33, 66, 4, 10, 48, 146, 201, 34, + 105, 132, 0, 110, 82, 38, 138, 228, 54, 141, 224, 132, 8, 98, 68, 96, 211, 40, 105, 129, + 192, 137, 129, 146, 140, 34, 134, 104, 97, 4, 9, 27, 22, 6, 8, 69, 128, 90, 136, 76, 4, 1, + 96, 65, 24, 113, 65, 22, 2, 98, 176, 141, 155, 136, 40, 131, 8, 12, 209, 38, 140, 36, 70, + 97, 68, 130, 112, 67, 20, 98, 100, 164, 136, 16, 64, 70, 201, 66, 45, 16, 71, 78, 163, 8, + 50, 160, 160, 33, 202, 182, 140, 17, 192, 12, 33, 50, 144, 2, 18, 45, 204, 196, 5, 73, 164, + 113, 202, 182, 4, 82, 160, 5, 224, 128, 132, 216, 160, 100, 2, 131, 41, 160, 166, 8, 32, + 148, 36, 20, 69, 2, 100, 184, 5, 163, 4, 4, 227, 70, 128, 68, 34, 40, 100, 6, 144, 88, 6, + 98, 147, 178, 37, 161, 70, 100, 2, 39, 4, 27, 168, 108, 73, 20, 137, 32, 41, 106, 209, 146, + 41, 17, 48, 97, 155, 6, 82, 26, 161, 68, 32, 1, 41, 36, 183, 132, 2, 33, 104, 225, 24, 137, + 36, 73, 109, 1, 70, 6, 33, 133, 104, 136, 56, 144, 80, 22, 49, 99, 56, 96, 138, 22, 108, + 164, 56, 81, 193, 0, 42, 217, 180, 40, 203, 40, 42, 162, 32, 48, 144, 18, 82, 129, 200, + 129, 9, 7, 17, 2, 57, 65, 195, 72, 129, 68, 196, 17, 24, 9, 80, 216, 68, 101, 27, 70, 114, + 155, 64, 142, 4, 149, 68, 11, 153, 137, 192, 34, 110, 146, 54, 96, 209, 22, 106, 155, 56, + 142, 33, 64, 50, 98, 0, 69, 1, 0, 17, 82, 66, 0, 216, 52, 140, 12, 165, 64, 8, 32, 6, 73, + 22, 38, 160, 176, 109, 131, 180, 100, 194, 160, 108, 155, 192, 49, 8, 185, 145, 97, 184, + 64, 0, 3, 76, 128, 6, 0, 152, 20, 6, 33, 129, 104, 4, 2, 142, 75, 64, 96, 66, 20, 108, 162, + 0, 64, 84, 32, 144, 2, 0, 1, 216, 180, 37, 220, 64, 97, 36, 150, 137, 12, 41, 70, 220, 200, + 128, 35, 167, 49, 4, 48, 32, 129, 32, 16, 196, 6, 41, 146, 168, 132, 8, 24, 40, 28, 6, 42, + 131, 50, 144, 152, 2, 32, 80, 196, 72, 132, 132, 49, 2, 198, 33, 36, 19, 66, 18, 5, 37, + 152, 180, 105, 27, 21, 137, 144, 198, 13, 11, 54, 6, 161, 50, 80, 25, 177, 129, 219, 40, + 133, 26, 51, 137, 32, 21, 0, 76, 22, 18, 75, 4, 100, 1, 19, 104, 32, 25, 16, 196, 134, 64, + 20, 40, 18, 0, 21, 110, 9, 32, 105, 32, 39, 78, 88, 18, 104, 72, 132, 49, 92, 34, 98, 64, + 4, 80, 202, 70, 101, 35, 193, 129, 65, 40, 133, 64, 150, 8, 200, 130, 0, 83, 6, 50, 0, 50, + 137, 0, 132, 105, 3, 183, 8, 99, 132, 109, 24, 36, 97, 34, 24, 33, 26, 20, 113, 76, 38, 81, + 24, 52, 130, 128, 128, 141, 10, 150, 100, 139, 22, 45, 18, 151, 41, 202, 148, 140, 66, 176, + 104, 132, 34, 38, 90, 64, 13, 200, 56, 128, 26, 128, 101, 201, 2, 32, 224, 72, 133, 2, 21, + 100, 36, 71, 2, 19, 16, 5, 10, 163, 45, 18, 37, 18, 11, 145, 45, 26, 19, 33, 98, 0, 138, 0, + 1, 8, 146, 148, 144, 196, 194, 145, 33, 194, 17, 228, 48, 33, 72, 38, 10, 96, 16, 73, 130, + 162, 129, 28, 1, 42, 200, 164, 40, 2, 134, 17, 156, 2, 140, 212, 40, 14, 33, 198, 145, 89, + 22, 37, 137, 70, 68, 1, 57, 40, 196, 32, 18, 27, 3, 82, 202, 200, 145, 147, 176, 96, 90, + 36, 98, 25, 144, 109, 212, 52, 33, 139, 152, 108, 66, 66, 68, 224, 166, 33, 18, 57, 9, 24, + 54, 13, 131, 36, 137, 1, 151, 9, 132, 70, 33, 203, 52, 100, 147, 66, 78, 140, 48, 132, 19, + 4, 136, 64, 68, 41, 76, 200, 36, 33, 9, 128, 137, 136, 49, 216, 200, 96, 8, 66, 16, 144, + 72, 112, 20, 198, 108, 130, 68, 108, 10, 17, 32, 96, 72, 69, 137, 22, 109, 26, 147, 45, + 127, 197, 232, 130, 20, 42, 161, 86, 15, 60, 40, 95, 41, 132, 143, 242, 13, 48, 67, 63, + 114, 35, 35, 84, 212, 105, 52, 114, 180, 200, 155, 117, 30, 105, 249, 236, 122, 31, 64, 62, + 159, 149, 78, 229, 57, 64, 97, 73, 226, 114, 235, 9, 104, 241, 61, 18, 65, 53, 92, 128, + 150, 251, 147, 173, 87, 251, 205, 151, 157, 91, 73, 240, 200, 237, 183, 78, 193, 103, 148, + 49, 0, 3, 108, 143, 37, 237, 194, 26, 216, 34, 76, 1, 192, 227, 39, 75, 32, 33, 62, 77, + 163, 3, 103, 244, 133, 73, 167, 197, 160, 155, 180, 97, 120, 11, 220, 164, 58, 155, 66, + 208, 101, 234, 186, 242, 108, 60, 201, 8, 191, 160, 238, 90, 216, 26, 82, 119, 33, 15, 131, + 254, 180, 133, 106, 198, 6, 142, 181, 138, 210, 226, 250, 7, 57, 69, 80, 142, 210, 213, 30, + 43, 207, 146, 207, 3, 144, 193, 199, 54, 88, 70, 152, 166, 96, 98, 192, 79, 234, 152, 169, + 164, 18, 6, 196, 3, 85, 223, 200, 67, 95, 5, 91, 110, 190, 58, 36, 60, 192, 13, 227, 228, + 226, 249, 250, 1, 129, 158, 122, 56, 120, 109, 65, 96, 178, 64, 38, 110, 199, 32, 66, 24, + 198, 26, 110, 226, 198, 136, 113, 191, 213, 243, 25, 24, 115, 105, 243, 80, 82, 193, 90, + 86, 233, 163, 70, 244, 107, 145, 211, 92, 192, 190, 192, 55, 252, 24, 238, 133, 21, 252, + 244, 217, 42, 46, 151, 74, 110, 143, 70, 21, 151, 216, 147, 11, 216, 76, 4, 211, 40, 61, + 227, 125, 216, 226, 68, 203, 53, 217, 239, 178, 122, 202, 44, 169, 208, 166, 56, 209, 245, + 122, 13, 205, 55, 122, 44, 124, 80, 29, 94, 213, 52, 212, 141, 96, 212, 45, 245, 75, 182, + 98, 215, 242, 245, 213, 149, 24, 15, 95, 8, 59, 185, 95, 0, 169, 108, 71, 192, 71, 202, 6, + 177, 210, 227, 140, 160, 32, 121, 158, 186, 92, 72, 11, 106, 5, 188, 249, 63, 58, 196, 101, + 153, 2, 73, 5, 244, 43, 43, 80, 18, 184, 53, 11, 69, 190, 55, 9, 58, 57, 128, 81, 32, 44, + 194, 68, 234, 110, 66, 253, 203, 63, 160, 61, 110, 166, 3, 174, 153, 198, 178, 188, 172, 6, + 193, 203, 98, 144, 253, 128, 49, 44, 42, 179, 149, 79, 9, 247, 85, 115, 202, 90, 46, 221, + 10, 216, 32, 66, 150, 215, 254, 63, 238, 108, 73, 33, 202, 253, 211, 155, 233, 178, 106, + 144, 170, 151, 23, 210, 82, 1, 69, 48, 21, 124, 56, 184, 199, 46, 236, 63, 68, 72, 244, + 188, 208, 124, 236, 123, 107, 202, 34, 249, 105, 243, 112, 150, 122, 9, 56, 190, 160, 114, + 247, 63, 103, 249, 107, 78, 128, 32, 79, 33, 162, 92, 203, 86, 35, 193, 237, 238, 253, 125, + 7, 10, 157, 56, 33, 159, 51, 16, 235, 206, 188, 74, 187, 245, 93, 33, 221, 118, 161, 248, + 168, 229, 116, 244, 160, 228, 73, 127, 62, 205, 18, 91, 127, 117, 161, 108, 7, 187, 83, + 149, 158, 65, 120, 41, 14, 214, 137, 67, 59, 190, 86, 32, 164, 35, 172, 112, 186, 11, 33, + 100, 119, 185, 143, 114, 82, 223, 142, 49, 212, 246, 131, 235, 78, 219, 138, 46, 90, 136, + 8, 60, 248, 226, 58, 108, 114, 200, 69, 141, 38, 236, 20, 168, 78, 239, 191, 72, 65, 209, + 148, 83, 90, 115, 76, 134, 3, 182, 52, 173, 183, 21, 85, 112, 226, 101, 176, 95, 197, 216, + 27, 223, 143, 239, 127, 8, 227, 238, 78, 139, 101, 219, 191, 246, 172, 3, 41, 30, 152, 191, + 157, 164, 149, 27, 162, 80, 223, 194, 150, 253, 127, 5, 239, 155, 111, 100, 63, 108, 253, + 147, 98, 8, 30, 89, 82, 96, 85, 8, 224, 148, 206, 3, 242, 161, 122, 128, 222, 157, 124, + 119, 138, 156, 188, 142, 107, 17, 187, 165, 147, 108, 6, 40, 89, 77, 240, 165, 60, 64, 18, + 183, 183, 176, 169, 114, 195, 138, 18, 105, 187, 116, 105, 56, 42, 2, 251, 242, 93, 73, + 153, 133, 172, 3, 217, 145, 0, 178, 189, 166, 110, 64, 105, 49, 217, 33, 101, 110, 148, + 184, 70, 168, 47, 176, 107, 186, 21, 121, 75, 41, 14, 152, 60, 148, 140, 226, 19, 67, 217, + 54, 189, 24, 192, 47, 165, 219, 190, 136, 187, 87, 25, 180, 227, 211, 17, 214, 198, 187, + 103, 82, 180, 30, 143, 13, 103, 205, 80, 240, 66, 238, 17, 22, 68, 78, 137, 53, 187, 0, 7, + 183, 122, 228, 180, 87, 125, 100, 213, 75, 125, 236, 4, 199, 125, 32, 252, 147, 161, 102, + 239, 91, 149, 173, 241, 143, 148, 147, 146, 176, 196, 250, 68, 86, 166, 224, 68, 10, 222, + 76, 222, 155, 102, 181, 252, 18, 227, 105, 123, 57, 35, 237, 186, 122, 127, 227, 227, 216, + 43, 94, 7, 69, 26, 207, 56, 29, 219, 235, 86, 229, 10, 168, 221, 212, 189, 140, 81, 230, + 217, 58, 160, 137, 64, 81, 230, 128, 40, 247, 193, 141, 87, 225, 219, 191, 46, 186, 217, + 147, 48, 31, 204, 110, 171, 62, 160, 202, 174, 201, 234, 73, 228, 16, 13, 177, 50, 124, 92, + 187, 54, 251, 186, 35, 26, 192, 125, 16, 160, 178, 103, 19, 127, 248, 197, 251, 56, 23, + 202, 187, 122, 194, 246, 201, 195, 190, 184, 10, 190, 60, 58, 74, 102, 176, 111, 130, 100, + 121, 105, 49, 116, 216, 12, 184, 46, 77, 186, 250, 41, 34, 146, 190, 82, 136, 142, 225, + 131, 45, 106, 145, 49, 63, 222, 48, 191, 129, 243, 141, 248, 174, 58, 153, 155, 163, 184, + 164, 80, 49, 16, 125, 253, 206, 1, 155, 199, 184, 158, 119, 213, 124, 121, 94, 25, 54, 206, + 109, 8, 84, 207, 127, 250, 117, 146, 101, 247, 13, 30, 7, 125, 14, 17, 176, 226, 185, 178, + 195, 109, 54, 118, 117, 93, 120, 248, 153, 73, 165, 196, 169, 210, 150, 62, 162, 18, 63, + 44, 220, 0, 217, 64, 253, 63, 250, 224, 45, 168, 23, 23, 135, 224, 230, 245, 137, 115, 219, + 156, 156, 226, 251, 104, 251, 180, 183, 179, 135, 224, 181, 134, 6, 92, 69, 38, 119, 186, + 176, 146, 249, 15, 163, 93, 102, 62, 86, 221, 176, 101, 250, 190, 34, 80, 228, 37, 114, + 198, 194, 227, 34, 143, 34, 220, 73, 202, 96, 233, 102, 48, 7, 73, 246, 72, 151, 193, 214, + 184, 243, 118, 175, 66, 216, 142, 38, 210, 113, 184, 71, 245, 44, 152, 208, 43, 24, 115, + 208, 201, 112, 130, 68, 6, 11, 220, 125, 13, 87, 239, 125, 23, 4, 166, 245, 104, 222, 245, + 146, 227, 49, 66, 159, 176, 130, 11, 20, 140, 218, 209, 242, 162, 43, 132, 167, 192, 185, + 201, 111, 95, 172, 217, 236, 201, 97, 63, 133, 89, 232, 17, 227, 26, 38, 224, 189, 8, 216, + 73, 167, 109, 106, 247, 130, 245, 62, 243, 130, 169, 195, 227, 237, 73, 61, 105, 83, 9, 98, + 102, 146, 38, 61, 73, 186, 85, 30, 93, 112, 155, 212, 187, 105, 64, 100, 11, 186, 149, 59, + 247, 184, 238, 51, 36, 211, 75, 240, 185, 54, 250, 78, 167, 234, 153, 76, 149, 38, 39, 214, + 90, 142, 171, 146, 45, 206, 35, 253, 134, 194, 126, 110, 63, 216, 92, 149, 114, 30, 0, 20, + 71, 249, 147, 216, 219, 100, 191, 232, 235, 209, 78, 38, 235, 142, 201, 203, 85, 88, 141, + 172, 198, 227, 252, 103, 198, 120, 52, 100, 4, 133, 159, 52, 42, 95, 37, 37, 187, 80, 48, + 112, 220, 188, 83, 47, 225, 117, 66, 59, 235, 192, 60, 107, 179, 101, 28, 135, 25, 47, 151, + 11, 102, 31, 79, 213, 250, 245, 61, 128, 59, 168, 6, 106, 196, 128, 205, 193, 70, 102, 78, + 71, 84, 25, 193, 253, 211, 22, 123, 248, 129, 55, 43, 251, 27, 243, 152, 56, 47, 233, 11, + 160, 199, 196, 114, 81, 170, 139, 252, 129, 51, 161, 12, 173, 223, 98, 96, 37, 8, 114, 33, + 254, 59, 33, 95, 79, 117, 98, 189, 97, 205, 54, 203, 97, 229, 74, 119, 4, 170, 197, 130, + 98, 239, 119, 223, 146, 229, 181, 115, 205, 142, 107, 237, 147, 203, 189, 47, 17, 228, 45, + 10, 248, 194, 253, 59, 23, 9, 200, 141, 102, 103, 67, 160, 135, 183, 107, 223, 84, 210, 49, + 93, 57, 117, 95, 130, 177, 199, 176, 250, 11, 73, 181, 254, 39, 103, 60, 121, 187, 160, + 182, 159, 172, 40, 65, 99, 9, 199, 196, 90, 210, 183, 241, 214, 239, 87, 122, 249, 230, 87, + 219, 103, 213, 209, 107, 34, 161, 161, 115, 16, 131, 239, 129, 207, 16, 177, 109, 177, 147, + 143, 152, 67, 94, 48, 14, 213, 116, 252, 7, 65, 190, 72, 131, 151, 19, 237, 244, 88, 59, + 105, 116, 85, 58, 236, 115, 240, 151, 201, 55, 236, 174, 44, 73, 58, 221, 65, 84, 157, 209, + 53, 244, 19, 231, 66, 147, 107, 33, 81, 165, 5, 92, 128, 161, 82, 98, 124, 155, 127, 204, + 18, 141, 79, 40, 243, 186, 145, 242, 51, 2, 241, 66, 148, 111, 180, 136, 139, 78, 47, 229, + 72, 121, 150, 169, 165, 72, 48, 251, 7, 239, 173, 28, 83, 195, 101, 133, 158, 248, 113, + 103, 152, 124, 66, 134, 143, 141, 225, 117, 242, 21, 36, 9, 149, 124, 177, 246, 170, 30, + 157, 231, 164, 28, 76, 38, 119, 80, 59, 192, 158, 118, 139, 18, 236, 22, 239, 139, 36, 88, + 227, 174, 174, 10, 29, 211, 61, 149, 134, 145, + ]; + let expected_pk_bytes = [ + 172, 57, 21, 137, 106, 84, 92, 210, 84, 135, 208, 132, 1, 214, 3, 201, 203, 177, 43, 37, + 17, 117, 184, 150, 68, 214, 89, 217, 62, 177, 164, 233, 88, 37, 188, 49, 182, 243, 64, 120, + 190, 34, 65, 17, 96, 31, 221, 55, 52, 236, 162, 185, 211, 234, 56, 32, 30, 243, 147, 38, + 17, 125, 165, 187, 144, 247, 242, 48, 15, 176, 29, 243, 219, 184, 69, 45, 191, 0, 16, 244, + 43, 6, 171, 51, 64, 84, 71, 231, 133, 114, 84, 251, 228, 222, 124, 16, 173, 90, 211, 233, + 52, 174, 99, 13, 61, 219, 55, 183, 12, 160, 246, 49, 122, 143, 217, 92, 103, 58, 143, 164, + 201, 13, 32, 142, 139, 213, 183, 116, 80, 131, 153, 180, 221, 112, 148, 57, 241, 192, 46, + 190, 212, 5, 218, 131, 83, 122, 70, 1, 6, 151, 129, 84, 230, 82, 142, 94, 85, 131, 69, 237, + 201, 231, 180, 224, 234, 151, 241, 56, 81, 7, 20, 107, 115, 40, 68, 99, 225, 142, 114, 169, + 94, 239, 57, 187, 143, 171, 30, 33, 194, 49, 14, 142, 37, 145, 26, 41, 23, 102, 5, 1, 5, + 228, 75, 53, 21, 150, 16, 231, 121, 176, 158, 89, 43, 0, 57, 10, 32, 23, 0, 227, 147, 101, + 171, 223, 14, 23, 103, 44, 19, 211, 6, 73, 121, 5, 221, 242, 193, 26, 174, 28, 83, 150, 1, + 228, 5, 140, 4, 117, 40, 10, 91, 239, 59, 241, 135, 97, 170, 133, 104, 217, 121, 10, 63, + 132, 49, 234, 132, 58, 217, 74, 143, 190, 9, 30, 211, 42, 171, 139, 210, 119, 23, 70, 190, + 94, 164, 77, 189, 169, 156, 25, 124, 159, 100, 189, 219, 50, 230, 91, 52, 138, 249, 112, + 119, 221, 25, 63, 196, 135, 213, 141, 48, 67, 220, 3, 66, 37, 201, 34, 231, 149, 204, 223, + 130, 60, 82, 242, 64, 84, 64, 21, 248, 78, 236, 156, 161, 48, 163, 25, 192, 0, 171, 65, 18, + 180, 206, 207, 60, 229, 205, 20, 128, 81, 221, 32, 194, 169, 70, 88, 126, 187, 70, 20, 89, + 187, 252, 117, 56, 164, 147, 208, 119, 255, 177, 114, 106, 26, 143, 135, 93, 196, 226, 66, + 160, 197, 203, 240, 107, 188, 224, 83, 106, 230, 159, 198, 55, 129, 72, 155, 142, 157, 186, + 222, 79, 228, 17, 66, 8, 115, 224, 219, 93, 101, 55, 221, 251, 102, 176, 239, 213, 191, + 150, 99, 21, 12, 85, 172, 219, 13, 255, 114, 47, 149, 198, 79, 178, 60, 45, 173, 233, 211, + 182, 35, 122, 213, 170, 172, 120, 28, 46, 93, 77, 6, 61, 115, 233, 164, 45, 118, 81, 153, + 221, 251, 63, 33, 161, 19, 90, 105, 30, 233, 235, 20, 118, 76, 124, 252, 173, 189, 168, + 159, 196, 205, 30, 132, 157, 0, 89, 22, 246, 118, 92, 119, 184, 216, 50, 57, 142, 43, 63, + 147, 41, 213, 134, 121, 166, 130, 138, 243, 209, 226, 89, 75, 162, 73, 249, 52, 115, 13, + 12, 47, 204, 181, 223, 222, 176, 68, 115, 92, 137, 206, 39, 110, 59, 73, 27, 113, 253, 15, + 208, 56, 120, 177, 217, 111, 19, 27, 213, 205, 170, 37, 109, 246, 207, 132, 176, 234, 180, + 186, 136, 152, 228, 149, 187, 153, 192, 231, 191, 22, 127, 202, 78, 65, 141, 59, 26, 25, + 144, 113, 220, 42, 21, 71, 247, 255, 215, 18, 131, 12, 176, 235, 97, 89, 213, 48, 142, 22, + 70, 64, 152, 236, 58, 18, 209, 173, 144, 198, 193, 247, 191, 51, 24, 107, 23, 239, 146, + 127, 206, 38, 27, 47, 177, 229, 240, 195, 187, 121, 19, 210, 28, 83, 105, 86, 129, 203, 15, + 1, 237, 122, 135, 212, 17, 87, 153, 128, 251, 58, 98, 80, 105, 217, 144, 247, 254, 202, 0, + 62, 199, 76, 216, 27, 168, 144, 29, 245, 12, 248, 205, 81, 198, 12, 155, 198, 221, 153, + 130, 83, 159, 148, 76, 25, 63, 87, 2, 198, 39, 227, 19, 12, 115, 158, 177, 34, 17, 152, + 129, 171, 230, 61, 36, 153, 86, 228, 95, 145, 163, 124, 44, 140, 105, 204, 203, 129, 44, + 209, 207, 248, 20, 4, 201, 249, 150, 163, 137, 132, 116, 31, 122, 21, 15, 231, 58, 87, 109, + 34, 219, 151, 82, 54, 136, 24, 95, 161, 95, 187, 198, 21, 247, 150, 113, 5, 132, 117, 235, + 159, 251, 192, 96, 63, 72, 9, 145, 166, 229, 78, 74, 18, 40, 11, 186, 203, 92, 35, 156, + 255, 136, 224, 151, 118, 178, 141, 235, 136, 161, 132, 209, 145, 168, 152, 60, 43, 131, 69, + 68, 112, 31, 250, 124, 151, 253, 196, 228, 226, 252, 93, 204, 47, 174, 30, 67, 35, 193, 28, + 222, 209, 142, 199, 152, 205, 209, 170, 18, 155, 38, 100, 38, 231, 31, 253, 161, 194, 81, + 159, 190, 57, 37, 52, 52, 55, 71, 10, 237, 95, 67, 37, 97, 76, 123, 20, 147, 89, 164, 134, + 124, 24, 32, 162, 20, 125, 176, 10, 196, 129, 13, 113, 245, 67, 157, 230, 178, 216, 220, + 119, 2, 93, 78, 211, 171, 202, 88, 164, 233, 200, 86, 11, 152, 174, 128, 123, 113, 211, + 154, 75, 163, 98, 206, 196, 130, 43, 132, 200, 137, 31, 122, 161, 151, 204, 217, 194, 131, + 153, 22, 177, 234, 192, 166, 198, 191, 52, 192, 228, 231, 183, 0, 7, 220, 1, 175, 251, 141, + 143, 10, 27, 187, 148, 167, 182, 19, 60, 82, 216, 144, 169, 200, 126, 2, 156, 22, 237, 17, + 160, 251, 167, 230, 118, 192, 134, 240, 141, 129, 11, 173, 65, 224, 165, 169, 231, 105, 60, + 16, 148, 101, 255, 224, 46, 207, 189, 77, 143, 218, 29, 117, 62, 152, 126, 218, 55, 118, + 75, 158, 28, 140, 219, 24, 227, 9, 15, 208, 242, 199, 36, 174, 24, 135, 95, 14, 99, 155, + 218, 165, 166, 124, 122, 178, 178, 130, 181, 227, 23, 194, 15, 119, 133, 226, 47, 162, 159, + 37, 71, 82, 232, 20, 44, 74, 235, 93, 207, 92, 131, 78, 184, 124, 140, 201, 130, 245, 228, + 39, 67, 23, 181, 180, 79, 196, 89, 93, 145, 67, 241, 152, 128, 4, 31, 59, 10, 144, 169, + 212, 219, 60, 44, 36, 68, 62, 98, 223, 157, 48, 207, 66, 254, 38, 140, 16, 38, 84, 76, 157, + 185, 8, 188, 110, 60, 244, 5, 102, 216, 224, 241, 210, 80, 140, 235, 170, 134, 200, 184, + 175, 2, 212, 63, 196, 219, 122, 54, 12, 31, 16, 129, 44, 10, 76, 241, 141, 152, 3, 48, 223, + 28, 202, 205, 76, 221, 193, 176, 92, 13, 89, 183, 191, 155, 84, 178, 108, 20, 200, 232, + 181, 245, 110, 83, 177, 114, 48, 119, 95, 148, 240, 219, 208, 80, 225, 59, 9, 14, 139, 81, + 219, 161, 130, 78, 58, 25, 76, 183, 190, 6, 118, 97, 93, 78, 202, 152, 167, 123, 184, 229, + 16, 90, 175, 160, 249, 59, 69, 185, 110, 72, 178, 233, 238, 251, 44, 114, 5, 114, 114, 141, + 160, 244, 82, 208, 174, 217, 60, 236, 125, 37, 245, 32, 201, 145, 203, 8, 148, 188, 26, + 229, 8, 64, 103, 231, 172, 100, 27, 230, 245, 182, 105, 70, 63, 237, 63, 136, 169, 194, + 254, 91, 197, 144, 194, 155, 119, 239, 187, 38, 198, 143, 154, 215, 207, 105, 88, 108, 47, + 196, 92, 38, 124, 188, 26, 36, 37, 213, 82, 180, 9, 196, 41, 21, 29, 57, 87, 243, 125, 189, + 201, 162, 60, 145, 222, 153, 230, 111, 187, 214, 113, 215, 207, 41, 193, 139, 53, 184, 253, + 56, 196, 22, 245, 181, 115, 9, 44, 157, + ]; + let expected_sig_bytes = [ + 247, 195, 46, 51, 218, 216, 250, 229, 211, 108, 79, 47, 229, 182, 89, 20, 131, 138, 176, + 140, 110, 86, 79, 162, 235, 53, 252, 99, 131, 166, 190, 111, 107, 48, 216, 84, 211, 37, 51, + 22, 15, 162, 55, 169, 176, 225, 30, 167, 17, 253, 59, 231, 203, 56, 100, 85, 81, 249, 104, + 114, 161, 203, 77, 246, 162, 93, 33, 88, 130, 209, 154, 100, 30, 178, 157, 82, 179, 131, + 17, 109, 71, 22, 243, 19, 146, 81, 116, 65, 60, 173, 85, 62, 221, 255, 245, 112, 199, 63, + 133, 197, 59, 217, 217, 95, 117, 92, 124, 254, 156, 26, 200, 123, 123, 230, 83, 73, 128, + 79, 6, 158, 243, 88, 112, 195, 235, 73, 35, 84, 142, 37, 151, 141, 24, 227, 247, 209, 141, + 39, 183, 45, 85, 152, 96, 196, 14, 225, 187, 10, 225, 86, 11, 83, 117, 179, 79, 122, 65, + 95, 52, 110, 18, 178, 170, 78, 171, 1, 236, 103, 138, 71, 84, 56, 118, 209, 69, 97, 206, + 39, 55, 163, 123, 102, 109, 152, 130, 72, 119, 133, 179, 18, 161, 56, 237, 171, 179, 229, + 103, 250, 150, 106, 155, 11, 42, 95, 86, 52, 67, 93, 109, 116, 210, 76, 16, 6, 209, 234, + 191, 236, 148, 208, 235, 48, 19, 227, 133, 252, 216, 34, 189, 217, 138, 109, 138, 185, 157, + 136, 117, 51, 137, 150, 99, 138, 133, 163, 7, 6, 250, 188, 239, 229, 225, 67, 148, 52, 9, + 90, 39, 96, 64, 117, 216, 126, 123, 99, 168, 140, 213, 47, 92, 78, 75, 233, 127, 211, 32, + 21, 26, 99, 39, 16, 141, 7, 50, 73, 44, 122, 9, 30, 185, 70, 247, 121, 237, 98, 203, 161, + 45, 59, 105, 123, 128, 77, 253, 205, 32, 180, 46, 102, 200, 0, 156, 98, 251, 127, 69, 34, + 8, 151, 155, 112, 2, 58, 212, 26, 252, 101, 127, 246, 124, 252, 204, 134, 104, 142, 215, + 170, 26, 249, 136, 116, 176, 8, 204, 195, 15, 123, 122, 30, 162, 129, 242, 187, 198, 212, + 86, 72, 120, 217, 179, 82, 118, 246, 63, 104, 102, 26, 163, 168, 59, 135, 167, 213, 68, 88, + 57, 139, 155, 34, 207, 121, 227, 226, 59, 135, 65, 70, 213, 176, 46, 108, 151, 168, 153, + 231, 92, 203, 249, 143, 20, 200, 22, 95, 187, 118, 230, 9, 227, 170, 97, 163, 130, 15, 174, + 45, 184, 244, 47, 136, 146, 68, 99, 33, 195, 130, 52, 52, 192, 118, 116, 176, 182, 18, 203, + 13, 214, 149, 0, 53, 77, 144, 55, 102, 32, 13, 6, 146, 7, 153, 120, 148, 245, 169, 208, 3, + 218, 9, 93, 222, 94, 9, 80, 231, 31, 41, 66, 92, 67, 58, 23, 68, 161, 15, 131, 65, 72, 181, + 93, 130, 209, 78, 3, 194, 154, 248, 64, 180, 38, 137, 92, 203, 149, 253, 109, 239, 95, 15, + 0, 118, 57, 18, 206, 13, 186, 139, 151, 82, 156, 159, 81, 222, 94, 39, 180, 230, 156, 223, + 159, 86, 255, 163, 141, 175, 133, 97, 173, 7, 245, 123, 154, 100, 226, 92, 170, 81, 116, + 30, 85, 170, 161, 115, 231, 184, 232, 158, 79, 130, 58, 75, 13, 22, 160, 133, 71, 92, 243, + 27, 51, 66, 223, 127, 137, 154, 146, 103, 205, 208, 14, 182, 193, 216, 162, 175, 200, 208, + 31, 101, 107, 22, 141, 227, 248, 178, 222, 230, 67, 241, 47, 1, 141, 111, 206, 169, 199, + 87, 84, 161, 197, 202, 172, 9, 118, 243, 63, 224, 79, 239, 87, 185, 0, 132, 4, 55, 219, 52, + 99, 210, 54, 249, 36, 127, 19, 5, 103, 3, 219, 108, 67, 96, 28, 214, 38, 147, 243, 30, 78, + 90, 244, 117, 60, 49, 237, 81, 15, 235, 197, 148, 125, 7, 147, 13, 253, 149, 214, 108, 53, + 43, 221, 3, 96, 235, 170, 119, 52, 3, 30, 70, 249, 204, 62, 165, 120, 150, 224, 135, 214, + 102, 82, 210, 218, 89, 12, 138, 98, 121, 253, 128, 254, 33, 7, 53, 98, 214, 182, 239, 170, + 200, 29, 56, 46, 150, 127, 48, 216, 189, 194, 74, 72, 97, 23, 142, 120, 243, 225, 248, 152, + 89, 163, 197, 143, 154, 46, 73, 135, 243, 92, 174, 169, 223, 220, 136, 92, 213, 87, 193, + 249, 77, 210, 102, 172, 117, 223, 203, 3, 185, 97, 154, 253, 228, 161, 54, 77, 220, 70, + 167, 101, 217, 210, 140, 234, 161, 217, 217, 49, 251, 33, 33, 127, 115, 45, 8, 118, 143, + 234, 100, 124, 156, 164, 212, 104, 39, 142, 243, 137, 56, 60, 189, 100, 95, 33, 88, 125, + 110, 193, 98, 121, 233, 95, 130, 99, 242, 64, 56, 236, 236, 3, 80, 114, 54, 123, 119, 243, + 103, 210, 220, 209, 230, 150, 254, 253, 134, 149, 51, 97, 138, 27, 225, 154, 61, 202, 26, + 39, 117, 183, 41, 219, 136, 25, 170, 169, 148, 0, 54, 190, 211, 155, 204, 246, 146, 138, + 226, 78, 81, 164, 8, 3, 87, 208, 162, 136, 10, 97, 130, 66, 18, 122, 111, 39, 253, 166, + 133, 0, 214, 245, 131, 83, 44, 7, 143, 170, 211, 20, 94, 198, 226, 154, 58, 229, 47, 27, + 59, 111, 92, 15, 30, 252, 105, 189, 139, 213, 12, 105, 0, 28, 42, 33, 215, 84, 224, 220, 3, + 168, 157, 58, 140, 0, 121, 199, 50, 57, 61, 38, 136, 224, 126, 170, 216, 111, 89, 4, 235, + 203, 102, 154, 49, 252, 70, 177, 65, 139, 26, 64, 69, 189, 245, 4, 239, 237, 5, 201, 206, + 130, 94, 74, 174, 242, 208, 92, 138, 21, 137, 227, 225, 77, 120, 101, 29, 77, 255, 253, + 214, 120, 237, 46, 82, 161, 109, 226, 124, 3, 85, 69, 99, 1, 197, 253, 198, 28, 222, 73, + 13, 76, 166, 24, 154, 43, 89, 20, 84, 158, 179, 59, 250, 222, 30, 140, 210, 159, 116, 251, + 35, 233, 21, 160, 146, 233, 95, 90, 160, 154, 116, 125, 85, 77, 164, 133, 133, 47, 37, 94, + 255, 153, 150, 139, 21, 117, 167, 143, 117, 206, 210, 26, 31, 157, 86, 236, 132, 188, 90, + 31, 102, 45, 110, 82, 71, 99, 36, 207, 236, 54, 75, 49, 182, 218, 166, 124, 131, 4, 248, + 193, 69, 47, 33, 151, 4, 205, 217, 104, 66, 249, 202, 28, 229, 65, 82, 209, 186, 239, 213, + 203, 95, 162, 29, 86, 49, 149, 69, 109, 117, 89, 75, 234, 211, 238, 102, 2, 51, 222, 248, + 85, 134, 175, 247, 178, 85, 253, 69, 43, 51, 0, 208, 227, 20, 205, 183, 84, 148, 18, 30, + 51, 95, 98, 17, 2, 217, 177, 93, 7, 203, 0, 17, 197, 253, 242, 114, 9, 215, 206, 105, 69, + 202, 71, 150, 126, 9, 222, 188, 69, 252, 252, 210, 206, 2, 179, 38, 131, 62, 0, 239, 186, + 73, 229, 133, 206, 60, 67, 50, 184, 64, 50, 92, 77, 191, 18, 232, 9, 59, 65, 126, 89, 2, + 241, 218, 161, 124, 52, 224, 29, 215, 56, 95, 230, 232, 227, 139, 134, 53, 165, 21, 5, 52, + 75, 41, 212, 161, 166, 96, 250, 232, 59, 211, 36, 19, 36, 142, 3, 4, 168, 59, 157, 223, + 231, 37, 143, 167, 111, 84, 18, 41, 49, 54, 164, 67, 136, 141, 67, 127, 150, 148, 81, 150, + 247, 47, 79, 161, 45, 164, 42, 189, 227, 141, 10, 90, 19, 152, 35, 23, 38, 158, 68, 175, + 103, 59, 210, 254, 251, 50, 64, 49, 199, 97, 27, 249, 85, 25, 59, 112, 149, 21, 2, 10, 38, + 171, 100, 89, 157, 220, 113, 162, 137, 254, 184, 33, 130, 53, 97, 238, 84, 233, 147, 121, + 95, 14, 168, 246, 166, 42, 205, 138, 246, 126, 79, 94, 32, 23, 253, 105, 219, 247, 78, 88, + 37, 195, 125, 85, 74, 241, 127, 236, 131, 40, 65, 150, 194, 149, 72, 181, 239, 132, 192, + 28, 196, 200, 203, 203, 53, 178, 253, 32, 245, 79, 118, 57, 51, 215, 245, 135, 213, 223, + 114, 16, 46, 240, 83, 80, 254, 28, 2, 245, 100, 248, 101, 114, 54, 160, 143, 221, 196, 207, + 76, 19, 28, 167, 59, 148, 210, 20, 75, 75, 255, 181, 174, 161, 8, 194, 240, 69, 118, 242, + 31, 250, 71, 148, 3, 56, 59, 251, 117, 11, 46, 126, 198, 184, 16, 254, 183, 199, 43, 211, + 139, 41, 222, 33, 165, 235, 156, 117, 180, 104, 229, 108, 98, 90, 71, 77, 198, 1, 91, 131, + 228, 255, 59, 228, 222, 38, 116, 117, 70, 84, 205, 157, 212, 114, 242, 202, 177, 73, 125, + 111, 190, 187, 183, 17, 111, 92, 37, 74, 237, 117, 15, 88, 210, 12, 132, 103, 90, 192, 233, + 60, 2, 5, 136, 184, 50, 88, 13, 143, 47, 2, 128, 246, 74, 39, 225, 147, 252, 247, 215, 35, + 44, 164, 255, 18, 209, 61, 79, 29, 206, 199, 170, 233, 122, 205, 198, 245, 83, 24, 159, + 140, 245, 189, 200, 46, 156, 151, 154, 188, 172, 7, 38, 185, 226, 33, 184, 67, 169, 76, + 104, 9, 233, 202, 107, 34, 85, 6, 186, 11, 82, 111, 3, 148, 241, 171, 20, 1, 205, 201, 194, + 208, 190, 156, 232, 72, 100, 189, 87, 123, 7, 192, 106, 81, 87, 99, 26, 154, 224, 191, 158, + 44, 149, 175, 250, 184, 83, 221, 17, 133, 99, 97, 167, 194, 78, 250, 97, 8, 183, 207, 19, + 143, 213, 160, 130, 89, 206, 45, 90, 253, 94, 111, 34, 192, 38, 137, 73, 241, 234, 73, 8, + 197, 200, 206, 12, 205, 60, 141, 34, 246, 157, 21, 226, 5, 88, 93, 27, 66, 75, 51, 91, 254, + 120, 215, 190, 129, 108, 165, 111, 41, 250, 91, 84, 7, 232, 108, 133, 91, 11, 236, 184, + 251, 13, 89, 29, 201, 230, 136, 18, 171, 9, 98, 56, 153, 229, 255, 232, 125, 114, 91, 132, + 37, 133, 7, 247, 182, 150, 113, 60, 242, 24, 51, 209, 35, 153, 84, 54, 167, 41, 185, 23, + 214, 91, 27, 163, 209, 254, 135, 179, 0, 171, 32, 178, 155, 42, 151, 215, 119, 23, 47, 246, + 51, 203, 255, 33, 193, 98, 39, 95, 74, 97, 168, 126, 221, 88, 23, 227, 75, 78, 90, 90, 72, + 27, 231, 140, 215, 224, 133, 128, 205, 31, 27, 47, 198, 142, 70, 88, 98, 22, 16, 192, 15, + 220, 245, 130, 211, 70, 3, 143, 56, 90, 184, 113, 196, 142, 207, 250, 60, 189, 83, 112, 97, + 33, 204, 255, 51, 210, 90, 137, 165, 151, 141, 207, 130, 153, 213, 117, 108, 42, 230, 176, + 126, 129, 228, 177, 16, 134, 27, 89, 114, 185, 145, 52, 115, 211, 31, 190, 125, 246, 232, + 154, 180, 88, 215, 211, 52, 46, 170, 36, 161, 153, 132, 252, 137, 131, 69, 243, 173, 126, + 175, 250, 25, 133, 185, 191, 14, 22, 141, 162, 194, 25, 62, 38, 117, 108, 78, 0, 148, 101, + 74, 227, 107, 106, 250, 95, 49, 69, 240, 0, 207, 169, 151, 70, 230, 160, 101, 87, 94, 201, + 144, 188, 149, 109, 18, 245, 142, 145, 211, 154, 225, 55, 141, 139, 199, 191, 64, 77, 186, + 41, 86, 201, 250, 211, 158, 23, 83, 202, 182, 61, 243, 184, 239, 203, 198, 0, 128, 237, + 224, 12, 88, 194, 43, 255, 6, 95, 23, 214, 70, 250, 237, 13, 19, 119, 207, 93, 0, 120, 141, + 65, 114, 84, 255, 27, 9, 137, 244, 186, 129, 142, 14, 27, 95, 184, 20, 189, 147, 36, 37, + 91, 246, 253, 183, 172, 16, 3, 170, 81, 172, 70, 89, 87, 135, 52, 125, 5, 255, 60, 172, + 206, 195, 105, 81, 100, 235, 98, 180, 85, 68, 135, 57, 208, 160, 148, 125, 118, 168, 122, + 90, 231, 24, 251, 153, 151, 102, 67, 181, 160, 236, 101, 149, 158, 0, 93, 153, 153, 8, 124, + 51, 116, 144, 112, 68, 24, 61, 150, 26, 236, 165, 136, 233, 41, 159, 152, 119, 9, 130, 86, + 42, 130, 13, 15, 205, 193, 0, 225, 20, 29, 167, 255, 56, 164, 5, 124, 155, 213, 116, 194, + 177, 116, 112, 244, 220, 23, 96, 125, 20, 139, 159, 56, 30, 183, 172, 136, 12, 98, 174, 52, + 173, 132, 119, 147, 73, 121, 192, 1, 97, 241, 115, 49, 42, 45, 236, 126, 10, 10, 102, 217, + 253, 66, 217, 143, 100, 193, 182, 220, 159, 194, 58, 112, 243, 21, 151, 109, 28, 127, 5, + 253, 207, 45, 182, 77, 78, 237, 64, 208, 139, 70, 176, 11, 97, 105, 231, 91, 205, 3, 175, + 158, 79, 15, 90, 197, 156, 5, 2, 247, 244, 135, 208, 189, 53, 8, 145, 96, 188, 65, 65, 240, + 168, 13, 50, 208, 140, 116, 224, 31, 42, 210, 23, 238, 117, 190, 3, 223, 84, 145, 109, 73, + 48, 193, 131, 190, 18, 67, 69, 43, 151, 129, 132, 113, 18, 118, 148, 114, 105, 218, 69, 82, + 253, 181, 56, 59, 159, 66, 245, 151, 52, 63, 176, 223, 61, 15, 20, 237, 159, 116, 198, 170, + 72, 70, 93, 105, 87, 5, 177, 251, 177, 2, 87, 109, 200, 218, 231, 175, 190, 246, 161, 14, + 238, 87, 76, 186, 199, 76, 192, 176, 144, 99, 150, 18, 230, 24, 101, 253, 61, 138, 17, 17, + 97, 90, 249, 228, 46, 42, 162, 180, 90, 201, 205, 183, 226, 76, 111, 68, 102, 227, 187, 51, + 70, 138, 241, 194, 149, 215, 252, 26, 225, 117, 6, 178, 108, 32, 11, 195, 143, 241, 239, + 250, 246, 253, 130, 108, 233, 176, 119, 95, 2, 218, 255, 34, 55, 122, 106, 227, 214, 132, + 105, 212, 21, 153, 167, 19, 51, 191, 76, 220, 88, 102, 146, 59, 55, 11, 26, 37, 76, 77, 91, + 93, 111, 117, 127, 148, 149, 154, 163, 170, 171, 187, 193, 198, 203, 245, 251, 254, 12, 29, + 41, 43, 55, 65, 69, 84, 89, 90, 101, 116, 212, 223, 247, 251, 38, 64, 98, 126, 137, 159, + 206, 219, 225, 227, 231, 241, 249, 36, 47, 53, 89, 115, 119, 132, 138, 147, 158, 162, 183, + 185, 188, 193, 210, 213, 224, 234, 247, 0, 0, 0, 0, 0, 0, 0, 0, 23, 39, 52, 72, + ]; + assert!(check( + &message, + &sk_bytes, + &expected_pk_bytes, + &expected_sig_bytes + )); +} + +#[cfg(feature = "dilithium3")] +#[test] +fn test_dilithium_c_sk() { + let seed = [ + 52, 166, 221, 136, 234, 227, 147, 111, 186, 59, 223, 206, 170, 74, 105, 113, 99, 233, 40, + 166, 71, 153, 84, 146, 19, 6, 73, 112, 4, 156, 128, 28, + ]; + let expected_sk_bytes = [ + 51, 143, 96, 180, 133, 202, 189, 211, 236, 214, 150, 104, 179, 21, 188, 143, 152, 94, 89, + 104, 25, 43, 33, 200, 227, 249, 190, 191, 78, 220, 110, 19, 144, 183, 100, 131, 134, 82, + 205, 132, 154, 105, 64, 2, 29, 158, 10, 134, 193, 77, 67, 217, 210, 24, 1, 224, 212, 51, + 76, 222, 99, 173, 210, 101, 128, 206, 251, 193, 122, 156, 105, 210, 58, 137, 221, 252, 183, + 155, 23, 53, 97, 8, 124, 57, 253, 163, 95, 172, 56, 217, 208, 102, 3, 52, 181, 5, 50, 99, + 53, 66, 114, 118, 52, 4, 101, 112, 55, 19, 38, 104, 102, 1, 103, 72, 117, 129, 88, 40, 81, + 129, 120, 18, 24, 67, 66, 102, 22, 55, 20, 128, 36, 37, 0, 97, 51, 71, 119, 84, 104, 18, + 102, 50, 38, 70, 119, 104, 67, 69, 120, 84, 3, 86, 35, 80, 39, 116, 129, 87, 85, 56, 56, + 134, 50, 1, 20, 96, 49, 113, 33, 136, 97, 85, 52, 133, 56, 34, 66, 72, 52, 119, 7, 55, 134, + 70, 81, 71, 18, 3, 50, 35, 80, 71, 34, 35, 4, 49, 70, 36, 134, 84, 100, 33, 104, 24, 35, + 130, 67, 64, 1, 97, 67, 68, 71, 87, 101, 49, 85, 24, 70, 131, 35, 96, 129, 117, 70, 128, + 40, 118, 99, 36, 116, 24, 69, 128, 132, 86, 96, 8, 50, 87, 99, 48, 100, 68, 39, 117, 103, + 3, 80, 19, 21, 69, 100, 32, 32, 132, 36, 129, 5, 16, 98, 52, 40, 102, 84, 97, 67, 65, 53, + 5, 101, 87, 88, 55, 17, 118, 72, 1, 80, 69, 50, 128, 16, 36, 81, 81, 102, 19, 56, 0, 72, + 132, 131, 119, 103, 36, 32, 97, 68, 34, 65, 66, 67, 104, 112, 87, 68, 97, 116, 3, 0, 7, 33, + 102, 50, 133, 22, 68, 69, 35, 86, 4, 113, 117, 98, 33, 51, 97, 129, 70, 18, 130, 135, 56, + 83, 38, 21, 67, 118, 5, 2, 51, 5, 114, 22, 130, 134, 16, 132, 19, 117, 88, 33, 56, 85, 114, + 85, 39, 103, 113, 38, 116, 98, 103, 18, 8, 97, 134, 119, 85, 96, 102, 67, 54, 48, 136, 39, + 0, 99, 112, 135, 66, 51, 129, 48, 133, 36, 56, 4, 56, 116, 32, 23, 54, 53, 71, 65, 6, 86, + 54, 104, 33, 64, 120, 100, 65, 136, 101, 82, 82, 66, 24, 118, 120, 86, 88, 48, 52, 4, 4, + 19, 99, 102, 5, 16, 65, 37, 53, 131, 117, 51, 130, 52, 120, 34, 112, 86, 104, 115, 35, 70, + 85, 52, 119, 65, 5, 96, 135, 100, 135, 1, 83, 113, 50, 101, 68, 114, 21, 85, 68, 50, 88, + 83, 68, 100, 0, 115, 114, 40, 6, 85, 70, 66, 70, 53, 99, 23, 55, 120, 8, 102, 16, 120, 72, + 16, 7, 136, 4, 136, 118, 118, 72, 117, 133, 80, 33, 52, 67, 133, 119, 136, 119, 33, 32, 70, + 48, 72, 19, 133, 86, 99, 56, 53, 80, 21, 33, 128, 16, 34, 55, 21, 55, 2, 33, 120, 83, 100, + 40, 85, 84, 85, 129, 81, 134, 120, 72, 132, 16, 133, 118, 2, 64, 115, 23, 67, 102, 102, 33, + 53, 99, 80, 120, 118, 69, 8, 112, 19, 64, 34, 84, 55, 38, 48, 104, 86, 56, 50, 131, 5, 3, + 22, 129, 101, 20, 2, 4, 101, 2, 48, 55, 103, 102, 3, 130, 56, 66, 88, 102, 103, 118, 20, + 39, 5, 84, 52, 70, 102, 80, 36, 96, 84, 133, 81, 100, 38, 133, 116, 67, 39, 133, 17, 84, + 96, 117, 82, 128, 80, 65, 16, 117, 133, 97, 131, 119, 82, 104, 66, 66, 8, 32, 66, 96, 16, + 68, 112, 39, 129, 17, 82, 34, 5, 37, 22, 7, 133, 104, 8, 55, 134, 7, 66, 52, 22, 54, 86, + 99, 32, 5, 32, 130, 96, 20, 134, 98, 130, 84, 66, 49, 23, 131, 85, 3, 3, 23, 81, 82, 71, + 21, 17, 98, 129, 38, 3, 3, 55, 49, 130, 119, 3, 113, 100, 85, 100, 70, 0, 4, 80, 7, 80, 69, + 40, 133, 37, 51, 130, 83, 1, 18, 21, 24, 119, 82, 64, 66, 20, 39, 134, 38, 102, 1, 20, 71, + 97, 48, 120, 66, 22, 3, 51, 18, 18, 48, 3, 54, 84, 39, 115, 85, 51, 69, 136, 85, 39, 115, + 84, 32, 32, 68, 115, 65, 24, 135, 118, 6, 54, 98, 118, 129, 35, 56, 134, 40, 22, 33, 21, + 32, 136, 54, 37, 20, 1, 68, 4, 20, 96, 119, 104, 23, 5, 69, 70, 56, 2, 120, 48, 132, 85, + 23, 133, 70, 119, 64, 83, 104, 66, 51, 17, 98, 52, 129, 21, 33, 135, 88, 32, 56, 2, 40, 68, + 83, 117, 87, 97, 131, 16, 82, 21, 101, 134, 116, 66, 116, 34, 116, 115, 53, 20, 3, 131, 38, + 4, 119, 1, 67, 64, 80, 2, 53, 104, 114, 128, 84, 35, 114, 49, 49, 8, 65, 19, 134, 18, 69, + 35, 71, 135, 1, 49, 134, 16, 115, 88, 38, 6, 39, 103, 118, 88, 115, 70, 133, 83, 53, 22, + 35, 64, 32, 37, 7, 72, 66, 35, 135, 68, 118, 103, 49, 80, 23, 51, 53, 69, 96, 1, 112, 83, + 24, 98, 53, 96, 18, 82, 18, 34, 64, 117, 104, 81, 49, 132, 65, 64, 36, 52, 98, 80, 52, 64, + 0, 113, 19, 36, 120, 81, 119, 98, 134, 102, 120, 24, 88, 135, 88, 48, 113, 133, 54, 52, 0, + 100, 119, 97, 36, 131, 0, 18, 0, 103, 102, 84, 98, 113, 3, 84, 69, 8, 67, 87, 70, 116, 35, + 68, 65, 80, 71, 99, 72, 86, 32, 32, 7, 2, 71, 3, 32, 112, 115, 1, 100, 100, 37, 70, 18, 6, + 4, 133, 134, 133, 38, 87, 130, 116, 88, 118, 98, 22, 119, 71, 49, 85, 53, 132, 21, 113, 21, + 80, 0, 96, 34, 119, 52, 20, 82, 119, 88, 20, 51, 129, 120, 21, 96, 82, 36, 97, 0, 119, 40, + 67, 71, 64, 68, 67, 104, 2, 56, 72, 23, 85, 118, 33, 97, 118, 116, 117, 70, 114, 32, 1, + 133, 48, 21, 8, 4, 133, 116, 38, 7, 5, 134, 32, 32, 115, 69, 33, 21, 64, 81, 68, 100, 117, + 134, 7, 48, 64, 67, 39, 88, 98, 39, 22, 67, 129, 56, 100, 34, 88, 6, 23, 50, 128, 133, 55, + 22, 135, 131, 16, 56, 55, 49, 98, 103, 54, 66, 54, 69, 116, 96, 56, 0, 134, 51, 56, 4, 2, + 135, 81, 66, 66, 53, 32, 39, 64, 35, 136, 53, 33, 134, 128, 104, 69, 114, 18, 86, 67, 2, + 82, 72, 35, 102, 86, 54, 67, 100, 71, 1, 6, 65, 8, 128, 32, 71, 68, 98, 54, 132, 36, 49, + 86, 135, 56, 51, 23, 24, 136, 67, 37, 8, 84, 22, 65, 56, 131, 40, 134, 80, 136, 51, 68, + 136, 22, 33, 40, 133, 98, 18, 50, 119, 134, 100, 51, 115, 23, 134, 116, 66, 136, 64, 104, + 3, 118, 96, 18, 129, 38, 130, 72, 103, 33, 1, 37, 101, 5, 68, 87, 88, 22, 17, 98, 136, 1, + 116, 2, 4, 0, 8, 84, 49, 72, 38, 53, 50, 2, 40, 5, 128, 80, 115, 38, 115, 52, 21, 68, 130, + 36, 1, 80, 96, 39, 70, 33, 21, 7, 134, 67, 68, 99, 55, 69, 81, 83, 119, 132, 54, 83, 80, 7, + 34, 80, 21, 51, 67, 130, 70, 6, 82, 112, 132, 133, 86, 119, 97, 118, 70, 130, 72, 0, 36, + 85, 114, 68, 114, 49, 19, 6, 18, 22, 97, 36, 38, 18, 64, 136, 7, 56, 54, 68, 17, 55, 131, + 88, 84, 1, 98, 136, 88, 119, 64, 131, 69, 87, 17, 98, 71, 67, 85, 33, 100, 33, 135, 52, + 116, 133, 119, 69, 56, 19, 130, 39, 50, 129, 134, 103, 132, 38, 5, 5, 68, 85, 88, 134, 34, + 34, 114, 53, 100, 83, 130, 52, 97, 21, 33, 22, 87, 33, 82, 32, 85, 18, 136, 35, 39, 56, 40, + 82, 97, 40, 118, 0, 100, 101, 3, 70, 50, 51, 116, 19, 70, 16, 67, 84, 37, 34, 35, 136, 100, + 113, 6, 68, 34, 103, 0, 96, 101, 18, 64, 102, 16, 85, 6, 132, 120, 36, 17, 32, 103, 4, 115, + 5, 100, 21, 136, 131, 133, 0, 6, 128, 133, 4, 87, 24, 3, 103, 102, 34, 88, 135, 130, 55, + 130, 7, 1, 133, 6, 54, 116, 40, 133, 88, 133, 117, 86, 1, 71, 68, 36, 129, 119, 36, 50, 65, + 32, 99, 134, 96, 24, 37, 37, 69, 2, 2, 18, 20, 128, 38, 53, 117, 99, 102, 99, 23, 132, 100, + 51, 129, 34, 38, 131, 5, 34, 3, 0, 4, 81, 5, 104, 23, 3, 72, 54, 66, 50, 87, 69, 131, 100, + 36, 172, 24, 37, 155, 250, 20, 199, 152, 174, 213, 191, 114, 125, 62, 167, 149, 222, 215, + 251, 140, 78, 82, 113, 124, 108, 251, 210, 127, 55, 37, 183, 120, 163, 7, 145, 109, 245, + 141, 218, 92, 58, 95, 5, 234, 199, 8, 15, 122, 152, 108, 179, 158, 55, 72, 106, 255, 42, + 115, 175, 86, 136, 196, 226, 49, 11, 214, 128, 135, 144, 38, 239, 31, 80, 243, 142, 84, + 203, 183, 91, 45, 216, 116, 237, 232, 123, 1, 5, 71, 141, 42, 46, 34, 114, 108, 213, 33, + 59, 234, 218, 199, 220, 114, 219, 244, 159, 73, 5, 6, 216, 58, 205, 231, 69, 24, 236, 212, + 251, 237, 59, 137, 234, 213, 229, 85, 207, 61, 156, 163, 14, 55, 140, 184, 231, 189, 237, + 251, 143, 128, 57, 169, 225, 164, 172, 181, 158, 174, 113, 157, 189, 124, 222, 254, 56, 16, + 87, 189, 13, 225, 138, 240, 9, 166, 143, 71, 72, 144, 177, 128, 226, 54, 89, 155, 123, 43, + 142, 125, 220, 105, 148, 32, 136, 77, 2, 59, 213, 86, 91, 134, 254, 153, 84, 143, 205, 227, + 15, 110, 39, 105, 114, 88, 59, 74, 125, 221, 218, 135, 48, 56, 30, 102, 151, 206, 116, 114, + 230, 160, 100, 183, 228, 160, 194, 7, 184, 40, 254, 195, 68, 207, 101, 70, 121, 117, 75, + 183, 17, 193, 176, 119, 215, 212, 212, 230, 50, 75, 163, 2, 32, 71, 101, 160, 119, 71, 122, + 144, 116, 111, 224, 14, 172, 80, 8, 39, 77, 35, 195, 152, 23, 185, 202, 160, 164, 194, 131, + 226, 230, 160, 135, 188, 86, 109, 44, 249, 192, 139, 163, 58, 138, 40, 163, 162, 172, 239, + 21, 250, 73, 135, 195, 140, 27, 148, 22, 76, 83, 32, 211, 247, 123, 19, 87, 203, 138, 36, + 233, 40, 181, 70, 168, 6, 63, 155, 234, 61, 6, 186, 207, 252, 65, 164, 50, 220, 16, 111, + 20, 147, 53, 55, 179, 176, 193, 207, 117, 201, 100, 42, 193, 128, 47, 77, 6, 40, 174, 106, + 139, 6, 254, 0, 119, 108, 161, 71, 25, 209, 106, 245, 40, 149, 139, 217, 101, 10, 56, 227, + 144, 63, 161, 69, 237, 90, 48, 44, 158, 24, 71, 166, 163, 112, 151, 47, 90, 116, 158, 73, + 2, 178, 102, 170, 180, 125, 126, 35, 200, 4, 45, 60, 167, 11, 77, 164, 164, 109, 182, 240, + 199, 169, 123, 89, 109, 216, 81, 97, 191, 215, 227, 234, 16, 140, 247, 154, 161, 187, 188, + 167, 241, 7, 228, 195, 209, 234, 38, 121, 140, 1, 18, 241, 131, 41, 105, 24, 159, 254, 114, + 106, 211, 147, 72, 83, 195, 107, 51, 251, 31, 26, 63, 211, 45, 243, 241, 29, 173, 181, 67, + 222, 198, 11, 186, 201, 60, 155, 45, 33, 86, 11, 177, 101, 39, 36, 111, 229, 245, 48, 28, + 121, 120, 90, 253, 69, 2, 183, 2, 24, 144, 137, 146, 171, 161, 101, 37, 13, 88, 187, 153, + 106, 118, 125, 246, 43, 248, 86, 230, 72, 200, 190, 64, 93, 159, 190, 159, 34, 68, 14, 32, + 103, 238, 20, 110, 160, 111, 244, 150, 206, 15, 205, 96, 232, 108, 253, 229, 126, 110, 0, + 201, 235, 4, 248, 63, 8, 86, 42, 24, 148, 152, 231, 134, 239, 124, 206, 143, 44, 184, 228, + 114, 15, 84, 136, 223, 59, 228, 147, 193, 254, 195, 64, 52, 150, 169, 168, 153, 129, 69, + 98, 90, 167, 67, 255, 88, 165, 144, 246, 132, 140, 164, 12, 192, 223, 142, 203, 7, 83, 212, + 251, 111, 129, 111, 189, 81, 129, 58, 183, 251, 60, 196, 73, 213, 105, 186, 227, 242, 38, + 27, 43, 70, 77, 13, 56, 107, 173, 107, 234, 61, 54, 213, 14, 69, 23, 64, 167, 193, 5, 139, + 57, 69, 168, 104, 99, 240, 124, 43, 72, 193, 18, 57, 7, 118, 34, 240, 7, 5, 28, 220, 95, + 79, 185, 216, 76, 18, 171, 153, 0, 54, 124, 92, 157, 74, 13, 254, 228, 58, 83, 66, 43, 88, + 173, 156, 31, 22, 134, 161, 42, 223, 55, 92, 72, 111, 198, 44, 233, 83, 229, 240, 185, 134, + 22, 142, 135, 214, 187, 17, 249, 60, 218, 35, 101, 5, 247, 44, 137, 41, 137, 219, 240, 194, + 225, 187, 9, 80, 253, 131, 189, 36, 79, 217, 8, 83, 213, 41, 124, 167, 36, 129, 230, 169, + 40, 74, 107, 2, 140, 67, 86, 90, 174, 100, 33, 1, 145, 215, 67, 168, 165, 233, 254, 166, 9, + 223, 165, 224, 250, 126, 15, 126, 193, 129, 23, 254, 143, 21, 115, 162, 227, 127, 142, 75, + 215, 87, 211, 113, 25, 29, 166, 106, 5, 143, 157, 185, 246, 14, 114, 132, 49, 189, 181, + 157, 106, 217, 62, 4, 43, 89, 163, 191, 174, 10, 225, 255, 45, 211, 180, 248, 86, 171, 175, + 31, 76, 153, 97, 106, 4, 198, 249, 173, 173, 166, 126, 62, 241, 136, 112, 46, 183, 52, 110, + 250, 191, 52, 8, 179, 162, 78, 205, 166, 61, 58, 242, 85, 169, 253, 92, 245, 178, 195, 71, + 247, 8, 48, 159, 196, 155, 175, 70, 241, 157, 168, 126, 212, 243, 23, 234, 73, 106, 174, + 190, 25, 63, 59, 60, 14, 39, 47, 251, 174, 137, 190, 226, 183, 94, 92, 147, 1, 134, 134, + 218, 95, 222, 251, 32, 244, 245, 47, 53, 123, 209, 191, 225, 151, 46, 151, 202, 111, 204, + 210, 10, 212, 124, 48, 138, 222, 222, 32, 55, 204, 83, 174, 227, 103, 93, 88, 167, 75, 216, + 21, 42, 184, 213, 182, 172, 25, 7, 242, 181, 58, 28, 141, 14, 92, 157, 91, 196, 58, 211, + 82, 132, 118, 161, 95, 141, 177, 173, 53, 249, 179, 20, 196, 19, 22, 4, 45, 245, 254, 99, + 144, 223, 168, 192, 141, 105, 19, 53, 55, 237, 44, 71, 235, 201, 228, 67, 213, 184, 17, 2, + 225, 38, 24, 22, 123, 102, 11, 88, 221, 156, 60, 13, 162, 222, 50, 75, 170, 25, 147, 118, + 166, 102, 119, 107, 235, 40, 173, 205, 160, 132, 192, 175, 176, 10, 111, 6, 241, 150, 110, + 243, 23, 60, 108, 251, 124, 65, 3, 130, 155, 144, 237, 156, 172, 34, 125, 97, 9, 89, 244, + 155, 156, 95, 217, 135, 82, 16, 56, 172, 55, 107, 2, 143, 93, 18, 217, 51, 101, 134, 18, + 209, 246, 203, 8, 203, 221, 222, 131, 147, 17, 159, 251, 82, 224, 238, 141, 158, 239, 154, + 20, 109, 25, 251, 114, 76, 231, 154, 241, 60, 24, 137, 50, 44, 80, 244, 115, 62, 102, 213, + 140, 235, 252, 179, 176, 141, 80, 32, 20, 14, 41, 184, 57, 70, 55, 89, 166, 126, 216, 16, + 172, 164, 39, 187, 90, 94, 27, 108, 87, 155, 158, 68, 89, 73, 131, 142, 149, 33, 162, 230, + 62, 242, 253, 33, 218, 31, 6, 111, 167, 84, 213, 59, 79, 130, 126, 158, 216, 254, 181, 213, + 225, 192, 30, 254, 238, 238, 22, 84, 251, 234, 107, 75, 214, 34, 144, 103, 228, 35, 25, + 230, 103, 24, 55, 88, 121, 230, 36, 85, 6, 198, 143, 78, 122, 168, 80, 24, 209, 94, 170, + 126, 200, 128, 145, 143, 187, 139, 50, 197, 33, 186, 174, 248, 103, 243, 168, 88, 226, 223, + 92, 160, 247, 197, 88, 115, 81, 2, 34, 188, 8, 32, 166, 44, 222, 144, 38, 9, 216, 217, 66, + 23, 22, 78, 211, 103, 15, 105, 59, 73, 164, 27, 9, 104, 185, 93, 35, 138, 3, 49, 81, 142, + 163, 144, 202, 12, 22, 80, 229, 100, 115, 236, 32, 205, 123, 199, 9, 63, 177, 199, 103, 5, + 85, 60, 64, 139, 26, 56, 142, 142, 145, 198, 227, 205, 200, 17, 88, 62, 83, 132, 94, 58, + 45, 111, 124, 71, 182, 238, 124, 160, 168, 98, 213, 160, 43, 12, 41, 210, 196, 251, 244, + 77, 156, 104, 113, 59, 90, 58, 56, 192, 74, 176, 7, 182, 72, 210, 216, 66, 245, 32, 23, + 194, 168, 100, 26, 112, 57, 1, 121, 154, 101, 241, 64, 168, 85, 76, 73, 35, 221, 37, 234, + 17, 236, 49, 144, 190, 174, 22, 78, 67, 23, 143, 213, 13, 181, 191, 207, 56, 86, 161, 204, + 229, 65, 77, 55, 104, 82, 26, 116, 153, 146, 151, 91, 250, 10, 207, 59, 235, 52, 172, 108, + 203, 90, 231, 217, 153, 92, 237, 100, 212, 141, 229, 203, 132, 73, 245, 241, 246, 192, 86, + 15, 20, 43, 9, 120, 137, 249, 141, 120, 229, 141, 239, 40, 152, 253, 63, 210, 194, 192, 89, + 124, 162, 195, 80, 85, 31, 202, 112, 71, 203, 0, 47, 243, 78, 12, 173, 188, 5, 193, 118, + 195, 179, 202, 114, 93, 42, 200, 165, 172, 29, 236, 24, 8, 216, 97, 72, 26, 168, 137, 206, + 115, 174, 77, 128, 192, 6, 205, 226, 233, 65, 40, 157, 182, 247, 69, 85, 82, 246, 37, 58, + 33, 100, 204, 64, 91, 198, 33, 84, 127, 32, 99, 253, 169, 117, 178, 217, 117, 159, 41, 115, + 173, 203, 68, 133, 70, 12, 247, 49, 248, 8, 191, 4, 157, 65, 182, 158, 151, 108, 213, 17, + 148, 249, 161, 45, 63, 6, 254, 154, 111, 168, 127, 142, 90, 95, 107, 112, 235, 124, 121, + 49, 138, 190, 109, 183, 243, 166, 211, 214, 113, 194, 254, 102, 158, 40, 49, 35, 47, 186, + 158, 72, 152, 237, 0, 66, 82, 241, 184, 248, 4, 209, 149, 57, 185, 85, 164, 9, 217, 22, + 179, 26, 209, 126, 214, 155, 200, 151, 23, 54, 99, 183, 106, 94, 199, 152, 49, 164, 129, + 31, 158, 67, 227, 55, 220, 53, 12, 169, 183, 40, 198, 184, 99, 175, 245, 84, 214, 95, 129, + 94, 4, 159, 241, 36, 53, 239, 160, 240, 221, 177, 68, 33, 62, 164, 187, 23, 33, 122, 239, + 195, 201, 27, 105, 135, 119, 133, 17, 210, 181, 216, 96, 177, 189, 183, 74, 178, 87, 122, + 65, 112, 70, 186, 146, 8, 106, 78, 138, 149, 157, 225, 216, 130, 212, 176, 21, 219, 197, + 73, 70, 102, 144, 251, 17, 203, 30, 218, 140, 209, 43, 71, 107, 111, 101, 227, 31, 233, + 182, 198, 253, 92, 163, 127, 202, 21, 196, 230, 123, 7, 178, 210, 23, 151, 30, 41, 139, + 126, 65, 84, 63, 65, 198, 254, 238, 64, 154, 90, 131, 105, 198, 224, 207, 44, 101, 78, 205, + 211, 227, 88, 79, 135, 81, 21, 129, 112, 208, 180, 130, 34, 197, 193, 230, 158, 69, 215, + 10, 93, 18, 122, 246, 51, 193, 137, 37, 176, 113, 234, 14, 25, 221, 121, 121, 43, 21, 23, + 151, 128, 216, 70, 141, 213, 31, 177, 44, 207, 96, 56, 106, 81, 102, 184, 25, 178, 218, 65, + 236, 68, 207, 212, 206, 100, 44, 92, 6, 20, 95, 148, 239, 76, 170, 49, 71, 144, 5, 229, 96, + 171, 207, 83, 99, 125, 241, 141, 45, 144, 168, 227, 34, 88, 224, 194, 105, 211, 137, 210, + 226, 59, 254, 46, 159, 62, 172, 137, 173, 193, 31, 50, 185, 210, 168, 245, 168, 221, 31, 0, + 183, 52, 187, 185, 238, 183, 232, 146, 199, 187, 229, 141, 230, 61, 148, 196, 231, 127, + 101, 136, 254, 173, 128, 212, 163, 228, 43, 40, 141, 162, 116, 196, 169, 200, 149, 63, 140, + 29, 7, 244, 118, 231, 58, 188, 242, 147, 240, 117, 62, 187, 102, 165, 105, 170, 185, 77, + 68, 62, 137, 147, 98, 183, 223, 62, 12, 113, 23, 229, 112, 189, 54, 73, 7, 187, 79, 40, 3, + 194, 161, 97, 117, 52, 122, 66, 39, 80, 154, 221, 65, 45, 200, 220, 23, 249, 105, 184, 232, + 0, 177, 180, 236, 133, 5, 164, 34, 169, 11, 106, 207, 13, 229, 54, 92, 25, 240, 169, 200, + 135, 126, 250, 161, 229, 44, 4, 199, 168, 70, 108, 26, 41, 249, 222, 68, 168, 156, 242, + 252, 47, 117, 1, 200, 59, 131, 202, 217, 178, 51, 71, 35, 215, 113, 70, 170, 71, 43, 131, + 62, 204, 201, 215, 222, 187, 23, 229, 88, 165, 117, 182, 250, 228, 58, 39, 39, 148, 33, 3, + 88, 108, 6, 89, 20, 96, 104, 171, 7, 100, 135, 112, 60, 194, 226, 24, 177, 66, 213, 107, + 130, 102, 209, 100, 30, 24, 91, 179, 154, 95, 243, 102, 72, 107, 161, 42, 21, 190, 173, 37, + 11, 99, 221, 148, 193, 94, 130, 96, 233, 222, 50, 35, 121, 181, 157, 188, 131, 59, 174, + 191, 130, 32, 249, 222, 255, 28, 238, 238, 40, 242, 126, 93, 46, 128, 128, 241, 47, 138, + 169, 22, 67, 64, 238, 60, 127, 155, 246, 18, 102, 171, 52, 176, 120, 87, 35, 158, 206, 45, + 76, 89, 79, 129, 246, 88, 82, 132, 146, 22, 172, 67, 124, 154, 164, 212, 137, 199, 12, 158, + 242, 16, 34, 3, 55, 160, 237, 47, 153, 84, 238, 125, 82, 252, 206, 57, 47, 185, 166, 188, + 166, 114, 183, 143, 109, 127, 9, 218, 86, 243, 14, 240, 187, 4, 174, 13, 78, 86, 134, 73, + 84, 222, 237, 229, 118, 188, 90, 195, 53, 91, 178, 8, 158, 224, 37, 217, 119, 11, 93, 243, + 195, 42, 251, 95, 26, 15, 125, 38, 110, 222, 210, 147, 137, 14, 70, 171, 9, 101, 230, 196, + 253, 151, 100, 195, 161, 134, 78, 168, 102, 240, 241, 133, 137, 117, 46, 143, 185, 244, 93, + 232, 92, 90, 98, 13, 160, 244, 115, 59, 203, 192, 167, 244, 233, 121, 229, 170, 81, 13, 2, + 97, 41, 40, 193, 158, 54, 253, 205, 111, 165, 5, 109, 127, 235, 198, 18, 56, 85, 191, 177, + 27, 35, 41, 197, 107, 34, 194, 127, 54, 172, 20, 166, 250, 31, 61, 9, 248, 82, 35, 186, 84, + 223, 166, 104, 86, 36, 173, 188, 58, 24, 169, 91, 135, 84, 139, 95, 179, 18, 34, 84, 66, + 244, 219, 67, 141, 66, 60, 83, 44, 94, 240, 146, 2, 76, 222, 136, 82, 95, 206, 59, 185, + 221, 157, 130, 117, 133, 32, 213, 165, 88, 115, 56, 83, 87, 219, 212, 33, 41, 218, 172, + 231, 17, 64, 239, 118, 179, 251, 78, 237, 249, 91, 136, 242, 27, 166, 134, 25, 121, 175, + 61, 6, 117, 232, 47, 71, 49, 90, 136, 153, 184, 108, 7, 84, 86, 162, 171, 237, 117, 121, + 140, 113, 40, 242, 1, 102, 33, 82, 24, 3, 98, 195, 0, 121, 134, 219, 55, 151, 89, 208, 214, + 208, 159, 249, 30, 182, 107, 163, 24, 237, 203, 172, 147, 181, 221, 3, 113, 81, 13, 105, + 57, 95, 180, 69, 13, 81, 47, + ]; + + assert!(check_sk(&seed, &expected_sk_bytes)); +} + +#[cfg(feature = "dilithium3")] +#[test] +fn test_dilithium_c_fixed_sk() { + let message = [ + 150, 99, 95, 28, 87, 255, 56, 113, 81, 156, 9, 80, 7, 80, 81, 222, 68, 17, 147, 106, 16, + 61, 124, 192, 74, 154, 16, 100, 204, 238, 141, 171, 82, 193, 81, 8, 148, 160, 117, 62, 2, + 6, 186, 84, 222, 213, 111, 183, 215, 97, 227, 72, 219, 116, 213, 82, 56, 174, 3, + ]; + let sk_bytes = [ + 119, 254, 34, 234, 204, 15, 174, 243, 92, 115, 150, 231, 206, 164, 71, 139, 213, 50, 94, + 194, 28, 121, 191, 247, 202, 174, 202, 152, 190, 237, 185, 47, 254, 2, 222, 30, 215, 46, + 109, 112, 29, 247, 116, 37, 151, 203, 19, 65, 54, 110, 157, 233, 219, 122, 64, 19, 249, + 153, 182, 109, 243, 134, 241, 246, 112, 44, 241, 223, 2, 223, 27, 52, 95, 123, 80, 109, + 201, 183, 136, 171, 49, 179, 5, 196, 70, 30, 181, 191, 98, 36, 55, 90, 155, 221, 75, 73, + 133, 4, 81, 4, 54, 101, 132, 52, 133, 100, 69, 131, 67, 37, 51, 102, 69, 35, 24, 20, 113, + 6, 17, 51, 35, 119, 71, 120, 38, 99, 84, 36, 128, 65, 66, 128, 36, 85, 69, 117, 54, 115, + 16, 99, 81, 55, 5, 130, 134, 84, 103, 114, 22, 71, 103, 35, 2, 71, 4, 82, 6, 98, 64, 32, + 128, 84, 54, 40, 134, 69, 48, 103, 133, 66, 102, 136, 34, 68, 4, 5, 7, 67, 20, 113, 80, 80, + 33, 88, 65, 117, 114, 67, 65, 6, 64, 2, 132, 119, 82, 23, 100, 120, 37, 37, 135, 97, 102, + 0, 118, 49, 53, 82, 104, 17, 38, 135, 134, 19, 66, 86, 88, 8, 114, 16, 101, 104, 66, 120, + 96, 133, 82, 8, 69, 22, 88, 88, 128, 135, 68, 34, 101, 67, 5, 88, 115, 67, 24, 33, 64, 130, + 64, 70, 39, 133, 20, 99, 71, 34, 136, 98, 81, 70, 98, 35, 50, 70, 53, 69, 72, 4, 134, 85, + 84, 135, 38, 72, 67, 115, 113, 24, 69, 113, 23, 114, 35, 116, 99, 135, 17, 33, 36, 84, 21, + 131, 112, 71, 53, 38, 96, 64, 86, 68, 1, 88, 103, 112, 22, 132, 134, 67, 112, 71, 85, 32, + 128, 35, 86, 38, 21, 115, 2, 133, 128, 103, 71, 66, 39, 32, 132, 103, 130, 102, 130, 104, + 53, 118, 37, 80, 68, 118, 135, 3, 53, 120, 97, 36, 82, 72, 23, 36, 68, 136, 50, 37, 56, 55, + 96, 3, 32, 67, 102, 128, 136, 1, 20, 3, 120, 23, 113, 5, 35, 35, 20, 65, 37, 69, 8, 49, 0, + 4, 6, 2, 23, 22, 4, 55, 16, 129, 5, 40, 32, 67, 131, 129, 32, 67, 64, 21, 99, 88, 56, 37, + 101, 134, 116, 56, 72, 50, 2, 48, 120, 117, 33, 117, 98, 0, 20, 84, 37, 81, 0, 97, 128, + 102, 85, 48, 96, 19, 21, 116, 84, 21, 115, 39, 50, 70, 5, 136, 132, 40, 22, 119, 3, 101, + 64, 114, 4, 64, 128, 34, 65, 1, 19, 70, 17, 52, 24, 118, 80, 87, 6, 65, 55, 128, 134, 51, + 82, 32, 37, 96, 68, 16, 66, 56, 131, 6, 33, 129, 72, 34, 39, 70, 129, 117, 19, 97, 103, 51, + 56, 131, 129, 83, 23, 112, 16, 5, 1, 81, 35, 134, 1, 101, 56, 38, 52, 116, 7, 114, 2, 98, + 37, 135, 68, 85, 67, 112, 132, 87, 129, 64, 120, 83, 64, 85, 134, 85, 23, 19, 132, 3, 117, + 85, 134, 64, 55, 68, 112, 104, 69, 69, 104, 54, 134, 131, 69, 40, 133, 116, 113, 64, 17, + 38, 52, 114, 98, 68, 22, 52, 101, 40, 34, 20, 67, 3, 117, 22, 132, 66, 64, 0, 24, 33, 24, + 0, 65, 128, 80, 23, 85, 113, 85, 21, 39, 23, 33, 23, 37, 81, 7, 112, 65, 65, 136, 67, 101, + 83, 8, 99, 24, 49, 97, 2, 131, 0, 18, 119, 0, 21, 134, 131, 8, 87, 119, 101, 114, 65, 56, + 86, 81, 129, 48, 18, 39, 117, 102, 81, 52, 67, 66, 130, 37, 84, 86, 68, 56, 87, 85, 48, 40, + 69, 135, 16, 98, 2, 18, 86, 135, 16, 134, 68, 66, 20, 52, 6, 1, 65, 0, 100, 50, 23, 132, + 51, 54, 32, 22, 18, 129, 0, 71, 4, 133, 49, 99, 64, 23, 3, 83, 64, 115, 96, 37, 97, 101, + 115, 2, 71, 21, 99, 104, 17, 101, 102, 18, 2, 135, 64, 80, 39, 66, 70, 64, 37, 16, 53, 19, + 1, 6, 85, 17, 1, 36, 23, 23, 8, 81, 32, 48, 100, 56, 22, 98, 69, 37, 49, 1, 2, 32, 104, 67, + 68, 55, 36, 67, 6, 7, 24, 17, 85, 67, 129, 99, 99, 52, 71, 36, 68, 81, 55, 7, 81, 38, 64, + 19, 68, 68, 116, 40, 101, 64, 1, 88, 100, 49, 4, 32, 68, 118, 88, 0, 134, 136, 67, 53, 99, + 71, 85, 130, 20, 86, 116, 22, 65, 99, 35, 40, 118, 96, 114, 20, 18, 98, 119, 18, 113, 98, + 112, 114, 103, 0, 37, 96, 50, 32, 23, 16, 53, 38, 19, 66, 37, 67, 86, 50, 56, 70, 100, 22, + 98, 3, 21, 4, 97, 23, 32, 18, 5, 39, 131, 20, 22, 129, 82, 36, 5, 84, 40, 101, 5, 115, 67, + 99, 88, 96, 131, 20, 19, 66, 84, 70, 16, 130, 84, 86, 22, 23, 19, 37, 118, 102, 70, 72, + 104, 80, 34, 7, 132, 83, 129, 83, 133, 117, 134, 98, 48, 83, 82, 20, 17, 88, 40, 49, 32, + 20, 5, 101, 114, 5, 36, 0, 69, 116, 103, 82, 23, 104, 19, 103, 55, 81, 129, 83, 96, 0, 53, + 114, 85, 19, 1, 99, 130, 51, 133, 97, 4, 33, 115, 49, 88, 17, 54, 48, 134, 33, 118, 81, 81, + 130, 65, 16, 128, 81, 118, 97, 38, 130, 72, 70, 117, 18, 118, 133, 36, 36, 118, 56, 8, 24, + 6, 54, 97, 22, 97, 116, 88, 55, 17, 115, 133, 0, 82, 133, 104, 131, 22, 66, 128, 1, 103, + 130, 37, 97, 134, 69, 81, 21, 97, 128, 52, 23, 85, 134, 80, 115, 136, 100, 22, 17, 48, 53, + 120, 86, 65, 102, 128, 82, 64, 16, 114, 38, 54, 114, 70, 115, 130, 18, 81, 35, 52, 53, 82, + 49, 69, 134, 72, 112, 72, 87, 120, 88, 96, 81, 33, 53, 1, 120, 21, 113, 96, 87, 56, 0, 128, + 8, 65, 116, 52, 98, 115, 38, 48, 82, 83, 86, 40, 20, 20, 84, 112, 133, 68, 19, 136, 67, 88, + 33, 49, 129, 67, 33, 67, 98, 103, 131, 87, 86, 67, 51, 50, 0, 39, 6, 117, 120, 133, 8, 65, + 84, 117, 129, 84, 49, 72, 131, 120, 1, 116, 129, 135, 20, 118, 132, 85, 112, 16, 21, 48, + 133, 52, 104, 99, 83, 116, 53, 40, 103, 17, 101, 64, 84, 128, 34, 52, 102, 35, 19, 131, 32, + 67, 64, 128, 65, 80, 69, 115, 64, 19, 98, 6, 53, 120, 116, 97, 82, 136, 85, 135, 16, 86, + 16, 56, 16, 3, 37, 16, 81, 55, 1, 7, 18, 54, 135, 67, 115, 68, 69, 84, 120, 34, 16, 66, 38, + 49, 21, 131, 55, 4, 67, 120, 35, 88, 97, 1, 51, 8, 8, 117, 16, 87, 52, 56, 64, 32, 19, 36, + 129, 67, 55, 101, 49, 128, 100, 37, 20, 54, 4, 54, 72, 40, 36, 88, 135, 67, 130, 71, 85, + 51, 128, 112, 84, 20, 103, 3, 116, 118, 87, 18, 131, 54, 81, 38, 85, 102, 6, 34, 100, 64, + 66, 117, 133, 22, 20, 116, 128, 6, 51, 118, 49, 129, 20, 22, 68, 116, 55, 6, 117, 130, 23, + 53, 85, 99, 100, 117, 104, 113, 19, 2, 34, 38, 19, 7, 33, 19, 67, 83, 49, 133, 113, 50, + 100, 119, 64, 17, 72, 116, 17, 17, 21, 86, 23, 112, 1, 96, 99, 86, 33, 54, 22, 65, 33, 135, + 3, 69, 82, 23, 66, 129, 23, 116, 51, 54, 33, 133, 85, 35, 1, 70, 130, 101, 96, 129, 128, + 85, 23, 131, 33, 80, 40, 118, 80, 23, 83, 56, 22, 32, 39, 32, 64, 68, 64, 120, 52, 54, 133, + 40, 82, 114, 39, 49, 130, 2, 132, 56, 100, 104, 3, 85, 48, 67, 128, 66, 72, 117, 133, 24, + 72, 129, 70, 39, 82, 53, 68, 32, 18, 37, 21, 103, 132, 83, 68, 48, 101, 83, 34, 68, 114, + 136, 82, 112, 52, 116, 119, 0, 70, 55, 135, 32, 97, 56, 81, 55, 18, 129, 128, 8, 39, 68, + 103, 19, 50, 37, 81, 65, 72, 100, 56, 5, 37, 20, 135, 129, 120, 97, 35, 130, 48, 132, 112, + 81, 80, 54, 18, 83, 18, 49, 87, 100, 98, 64, 20, 131, 135, 24, 8, 120, 120, 104, 85, 131, + 37, 129, 99, 8, 50, 80, 113, 114, 102, 34, 37, 112, 64, 35, 18, 131, 117, 37, 72, 20, 98, + 36, 40, 16, 71, 84, 21, 18, 33, 55, 56, 54, 54, 8, 16, 34, 50, 2, 4, 49, 51, 50, 96, 100, + 136, 87, 97, 104, 88, 36, 98, 86, 19, 6, 16, 69, 69, 113, 49, 2, 97, 48, 136, 130, 24, 38, + 0, 87, 32, 56, 33, 186, 206, 175, 59, 5, 247, 230, 71, 109, 213, 103, 235, 237, 81, 241, + 91, 225, 219, 180, 201, 206, 130, 201, 219, 183, 118, 67, 101, 203, 13, 238, 154, 230, 158, + 73, 10, 157, 244, 137, 13, 132, 77, 243, 158, 247, 204, 155, 133, 85, 144, 238, 94, 1, 170, + 236, 48, 119, 154, 126, 14, 105, 249, 82, 178, 244, 76, 179, 86, 95, 249, 29, 140, 207, 60, + 143, 24, 76, 145, 178, 126, 204, 97, 64, 130, 43, 165, 62, 168, 9, 233, 202, 243, 207, 254, + 43, 242, 228, 159, 40, 103, 114, 77, 127, 243, 209, 193, 78, 56, 2, 241, 112, 94, 153, 157, + 200, 97, 66, 222, 55, 228, 72, 94, 188, 90, 74, 202, 192, 105, 125, 7, 63, 189, 209, 94, + 169, 194, 56, 100, 160, 68, 189, 246, 4, 68, 109, 180, 101, 78, 9, 16, 124, 106, 205, 213, + 151, 208, 56, 7, 47, 27, 179, 115, 249, 210, 140, 142, 127, 172, 6, 130, 171, 88, 243, 161, + 149, 102, 32, 16, 22, 189, 52, 4, 236, 37, 20, 147, 108, 247, 174, 186, 40, 235, 203, 101, + 207, 60, 210, 5, 40, 188, 63, 226, 147, 178, 9, 177, 172, 218, 192, 243, 126, 110, 90, 19, + 41, 99, 128, 97, 64, 235, 196, 214, 79, 186, 119, 167, 194, 183, 116, 236, 85, 224, 136, + 251, 9, 21, 119, 224, 199, 181, 75, 216, 130, 159, 36, 246, 153, 22, 69, 14, 72, 26, 78, 3, + 254, 37, 209, 111, 112, 63, 150, 116, 25, 28, 149, 202, 147, 105, 37, 2, 42, 100, 102, 196, + 36, 66, 37, 79, 208, 65, 167, 95, 84, 191, 221, 79, 12, 190, 248, 25, 9, 158, 0, 95, 126, + 225, 241, 9, 22, 183, 66, 49, 220, 149, 237, 232, 237, 147, 54, 197, 50, 126, 2, 23, 99, + 147, 109, 176, 182, 212, 37, 144, 203, 183, 145, 23, 14, 220, 204, 130, 124, 91, 111, 88, + 115, 133, 32, 3, 55, 178, 253, 28, 68, 121, 60, 90, 255, 80, 149, 158, 178, 26, 224, 167, + 42, 192, 165, 75, 109, 201, 47, 8, 54, 98, 205, 98, 63, 93, 203, 252, 126, 58, 118, 49, + 102, 74, 129, 55, 184, 76, 71, 60, 188, 152, 18, 164, 225, 97, 212, 2, 161, 244, 103, 110, + 197, 187, 85, 114, 110, 43, 203, 198, 56, 205, 107, 102, 47, 237, 223, 116, 92, 122, 194, + 96, 179, 245, 5, 142, 142, 254, 78, 141, 51, 250, 91, 169, 192, 230, 184, 242, 38, 152, + 156, 233, 47, 49, 148, 231, 53, 79, 222, 117, 77, 36, 87, 68, 154, 76, 48, 112, 151, 166, + 198, 111, 46, 51, 141, 120, 242, 116, 136, 45, 152, 16, 159, 219, 8, 231, 214, 252, 241, + 208, 148, 210, 68, 36, 21, 246, 170, 107, 180, 127, 208, 39, 231, 156, 199, 89, 246, 139, + 151, 44, 3, 56, 26, 255, 19, 42, 104, 246, 20, 201, 24, 220, 106, 16, 79, 32, 24, 181, 91, + 41, 166, 66, 17, 96, 155, 187, 106, 219, 124, 144, 38, 77, 16, 88, 247, 33, 168, 61, 70, + 242, 144, 38, 51, 126, 91, 54, 226, 20, 200, 172, 147, 96, 45, 130, 23, 177, 46, 83, 186, + 221, 232, 92, 229, 168, 28, 41, 24, 36, 47, 91, 16, 178, 6, 227, 193, 92, 86, 44, 237, 177, + 248, 87, 73, 38, 157, 96, 85, 97, 133, 50, 167, 203, 118, 117, 230, 205, 79, 187, 45, 141, + 182, 7, 71, 132, 199, 101, 31, 163, 157, 67, 38, 29, 40, 75, 128, 49, 122, 251, 36, 54, 8, + 244, 71, 39, 59, 94, 156, 235, 233, 73, 97, 37, 143, 48, 170, 201, 158, 97, 229, 170, 146, + 120, 247, 85, 156, 244, 226, 40, 213, 14, 34, 44, 56, 76, 119, 140, 248, 217, 0, 211, 18, + 174, 66, 22, 27, 228, 199, 215, 209, 252, 178, 179, 80, 247, 122, 121, 82, 110, 59, 5, 32, + 65, 76, 45, 105, 250, 15, 58, 134, 71, 87, 157, 89, 224, 110, 116, 140, 214, 133, 56, 226, + 252, 229, 134, 228, 229, 253, 96, 72, 212, 48, 70, 48, 121, 111, 89, 74, 146, 28, 11, 28, + 167, 176, 148, 139, 255, 77, 159, 76, 214, 94, 107, 243, 228, 122, 16, 105, 16, 12, 51, + 234, 240, 211, 112, 24, 186, 254, 47, 201, 181, 202, 86, 46, 89, 35, 94, 207, 168, 215, + 220, 111, 123, 218, 238, 20, 35, 60, 148, 160, 103, 108, 115, 103, 180, 150, 53, 15, 74, + 37, 14, 160, 36, 145, 61, 212, 232, 82, 96, 205, 6, 65, 217, 195, 235, 213, 102, 100, 131, + 163, 253, 219, 255, 122, 15, 46, 141, 250, 3, 59, 253, 132, 51, 96, 179, 176, 183, 242, + 168, 89, 18, 78, 182, 10, 8, 170, 128, 210, 7, 72, 247, 136, 80, 228, 164, 213, 70, 242, + 21, 168, 33, 13, 10, 196, 0, 191, 54, 251, 155, 206, 21, 145, 251, 25, 58, 137, 27, 164, 1, + 100, 109, 244, 60, 66, 210, 201, 253, 139, 225, 241, 10, 113, 12, 5, 80, 217, 122, 89, 168, + 172, 164, 141, 123, 106, 141, 15, 222, 45, 83, 108, 117, 140, 236, 17, 166, 89, 113, 59, + 245, 22, 40, 136, 87, 184, 215, 236, 46, 85, 73, 91, 188, 244, 55, 39, 211, 151, 37, 220, + 243, 255, 108, 112, 75, 31, 209, 158, 162, 110, 214, 97, 44, 164, 170, 222, 142, 29, 149, + 210, 107, 158, 16, 55, 135, 51, 135, 201, 69, 104, 237, 28, 56, 70, 43, 71, 133, 3, 174, + 190, 87, 9, 204, 227, 16, 46, 55, 95, 9, 140, 73, 214, 197, 169, 226, 22, 235, 93, 120, 76, + 47, 248, 2, 29, 186, 0, 39, 161, 200, 179, 132, 125, 81, 36, 22, 202, 247, 183, 225, 152, + 44, 175, 130, 150, 29, 128, 93, 238, 59, 1, 66, 210, 171, 82, 244, 84, 48, 226, 30, 164, + 20, 31, 57, 133, 25, 253, 99, 189, 59, 231, 3, 253, 103, 218, 251, 3, 68, 43, 207, 239, 19, + 45, 152, 29, 95, 145, 186, 186, 223, 221, 28, 138, 213, 192, 199, 20, 57, 199, 127, 14, + 204, 242, 237, 105, 202, 175, 20, 66, 167, 139, 8, 246, 8, 73, 195, 91, 76, 109, 4, 198, + 77, 33, 34, 237, 106, 243, 74, 131, 209, 76, 171, 208, 221, 110, 114, 251, 204, 183, 41, + 50, 67, 41, 73, 161, 180, 181, 206, 173, 229, 166, 122, 231, 110, 60, 16, 252, 197, 86, 32, + 131, 146, 136, 135, 43, 126, 235, 140, 105, 80, 137, 181, 208, 128, 47, 30, 68, 52, 125, + 136, 119, 142, 10, 1, 99, 121, 149, 168, 228, 19, 200, 115, 83, 17, 40, 40, 149, 203, 89, + 170, 187, 232, 15, 90, 143, 84, 83, 20, 71, 3, 201, 177, 0, 109, 99, 100, 92, 90, 251, 248, + 124, 118, 131, 102, 227, 115, 53, 70, 80, 173, 106, 216, 250, 50, 218, 114, 23, 117, 86, + 189, 168, 192, 240, 48, 124, 109, 60, 61, 10, 115, 182, 178, 102, 115, 62, 142, 17, 158, + 41, 249, 210, 106, 90, 41, 129, 20, 210, 224, 243, 61, 0, 161, 179, 143, 29, 156, 3, 64, + 216, 44, 172, 84, 21, 86, 55, 52, 152, 163, 49, 17, 131, 230, 115, 161, 114, 127, 214, 208, + 246, 104, 84, 53, 25, 210, 18, 48, 169, 55, 205, 55, 240, 188, 189, 236, 193, 8, 220, 238, + 78, 124, 133, 58, 2, 175, 155, 8, 76, 170, 41, 142, 173, 115, 147, 12, 31, 176, 5, 241, 83, + 93, 54, 229, 155, 128, 33, 90, 252, 127, 242, 143, 143, 4, 51, 222, 158, 145, 27, 24, 12, + 186, 193, 87, 43, 60, 31, 233, 225, 11, 166, 14, 89, 57, 205, 89, 241, 138, 105, 58, 134, + 55, 72, 67, 27, 198, 71, 36, 102, 211, 77, 44, 151, 52, 151, 64, 159, 194, 45, 11, 17, 155, + 1, 134, 135, 81, 238, 51, 29, 115, 215, 31, 186, 82, 63, 89, 150, 150, 101, 202, 147, 211, + 62, 194, 27, 91, 173, 125, 225, 191, 92, 60, 93, 122, 105, 224, 93, 176, 71, 110, 122, 0, + 83, 220, 78, 34, 189, 86, 80, 73, 224, 118, 142, 231, 56, 5, 243, 165, 190, 253, 202, 60, + 0, 116, 197, 172, 201, 23, 26, 86, 159, 151, 44, 131, 243, 4, 213, 89, 4, 217, 137, 82, + 204, 24, 95, 72, 122, 176, 66, 41, 141, 143, 28, 155, 50, 216, 139, 99, 127, 46, 77, 102, + 94, 64, 180, 112, 170, 135, 60, 168, 131, 48, 100, 96, 221, 58, 11, 145, 37, 13, 190, 23, + 184, 214, 92, 212, 44, 83, 77, 10, 182, 72, 242, 151, 67, 59, 180, 107, 18, 175, 190, 10, + 7, 239, 211, 252, 157, 217, 217, 247, 46, 34, 80, 224, 44, 114, 72, 19, 16, 248, 229, 236, + 130, 132, 163, 153, 159, 117, 38, 14, 146, 67, 2, 211, 196, 23, 114, 255, 116, 51, 195, + 207, 98, 146, 129, 148, 24, 50, 111, 67, 205, 229, 55, 72, 191, 160, 203, 227, 73, 103, + 156, 146, 80, 53, 129, 241, 211, 129, 79, 77, 163, 196, 7, 142, 216, 161, 175, 142, 71, + 215, 98, 121, 69, 255, 156, 84, 249, 140, 232, 2, 217, 121, 93, 240, 17, 114, 166, 94, 93, + 18, 110, 122, 198, 99, 13, 113, 197, 91, 110, 137, 26, 110, 116, 145, 11, 255, 127, 72, 17, + 146, 43, 159, 17, 223, 156, 62, 219, 44, 127, 18, 155, 170, 221, 10, 27, 183, 143, 129, + 249, 172, 86, 55, 77, 203, 41, 107, 242, 53, 55, 171, 130, 153, 62, 221, 11, 198, 210, 52, + 121, 204, 69, 15, 195, 196, 151, 109, 76, 196, 22, 72, 188, 199, 55, 80, 222, 43, 197, 204, + 70, 32, 144, 58, 181, 75, 156, 66, 153, 77, 101, 121, 152, 25, 190, 131, 251, 223, 125, 70, + 88, 143, 142, 241, 106, 234, 219, 184, 136, 112, 25, 47, 52, 136, 2, 180, 69, 115, 191, + 238, 220, 41, 214, 138, 246, 90, 68, 149, 41, 76, 50, 4, 211, 243, 47, 73, 135, 86, 63, 87, + 110, 156, 173, 251, 227, 82, 43, 114, 243, 138, 188, 221, 156, 191, 65, 76, 124, 207, 116, + 49, 105, 107, 216, 251, 130, 171, 206, 153, 152, 102, 85, 70, 212, 225, 14, 169, 172, 153, + 1, 103, 29, 182, 203, 148, 80, 234, 47, 21, 61, 82, 173, 103, 237, 149, 9, 143, 204, 232, + 204, 25, 31, 150, 63, 237, 12, 4, 246, 143, 117, 188, 107, 7, 214, 64, 200, 97, 198, 211, + 202, 161, 30, 205, 23, 163, 58, 147, 126, 27, 191, 244, 128, 85, 242, 234, 177, 240, 45, + 237, 94, 90, 134, 241, 249, 84, 54, 20, 233, 249, 245, 117, 203, 239, 37, 105, 179, 174, + 208, 128, 130, 70, 36, 74, 76, 161, 116, 160, 189, 195, 99, 225, 1, 40, 157, 13, 189, 62, + 89, 92, 229, 114, 19, 23, 250, 208, 215, 148, 132, 212, 112, 122, 206, 145, 136, 248, 175, + 84, 73, 47, 5, 117, 195, 104, 30, 81, 244, 117, 116, 45, 94, 19, 16, 246, 189, 181, 164, + 130, 159, 202, 76, 233, 192, 93, 218, 218, 33, 160, 186, 234, 99, 107, 197, 60, 167, 182, + 141, 47, 47, 179, 152, 6, 112, 7, 177, 39, 168, 2, 193, 57, 11, 147, 203, 211, 188, 9, 243, + 101, 229, 155, 16, 206, 253, 203, 61, 43, 43, 251, 239, 180, 179, 187, 144, 118, 135, 254, + 151, 76, 43, 65, 254, 75, 38, 132, 89, 23, 218, 155, 152, 202, 110, 118, 198, 45, 122, 214, + 234, 239, 158, 4, 244, 102, 100, 222, 102, 116, 186, 152, 128, 164, 23, 173, 135, 100, 177, + 242, 186, 229, 210, 99, 209, 204, 44, 236, 12, 118, 49, 49, 194, 106, 46, 103, 137, 221, + 171, 197, 32, 61, 57, 70, 93, 237, 11, 60, 195, 152, 175, 94, 64, 173, 246, 230, 151, 215, + 104, 96, 189, 55, 198, 30, 98, 235, 184, 219, 146, 21, 0, 41, 41, 248, 124, 138, 107, 92, + 8, 143, 209, 71, 11, 79, 173, 245, 166, 232, 59, 154, 163, 138, 122, 70, 9, 237, 45, 66, + 184, 205, 201, 67, 133, 232, 230, 180, 120, 85, 110, 240, 46, 195, 108, 166, 229, 84, 220, + 39, 204, 15, 28, 168, 38, 161, 81, 185, 185, 0, 82, 43, 68, 92, 90, 195, 66, 128, 160, 147, + 115, 99, 107, 60, 86, 245, 72, 158, 26, 149, 182, 140, 179, 222, 252, 97, 137, 247, 252, + 190, 21, 64, 231, 194, 254, 157, 107, 48, 168, 124, 69, 204, 24, 26, 23, 145, 198, 158, 87, + 83, 217, 101, 13, 16, 84, 80, 165, 44, 69, 17, 153, 202, 191, 42, 55, 52, 56, 116, 127, 90, + 235, 124, 75, 255, 110, 222, 31, 125, 223, 99, 94, 246, 123, 47, 218, 124, 28, 81, 116, + 133, 201, 51, 93, 40, 144, 181, 184, 86, 50, 52, 64, 247, 118, 50, 140, 182, 151, 165, 24, + 125, 22, 128, 102, 194, 211, 224, 125, 178, 145, 235, 174, 118, 234, 100, 93, 40, 155, 124, + 95, 82, 171, 194, 2, 93, 147, 124, 45, 112, 192, 12, 226, 129, 228, 88, 69, 145, 78, 168, + 103, 128, 75, 152, 226, 164, 172, 79, 28, 134, 217, 166, 120, 172, 164, 189, 81, 54, 174, + 254, 58, 195, 28, 97, 232, 147, 42, 116, 156, 237, 129, 23, 68, 187, 210, 45, 24, 55, 105, + 45, 55, 235, 99, 114, 224, 238, 2, 76, 105, 110, 46, 26, 53, 220, 15, 254, 182, 201, 139, + 114, 72, 61, 155, 200, 196, 71, 74, 56, 227, 249, 235, 38, 135, 35, 67, 111, 246, 230, 128, + 208, 129, 115, 8, 171, 24, 176, 121, 159, 73, 73, 228, 197, 238, 86, 0, 225, 167, 168, 213, + 64, 111, 19, 51, 30, 76, 153, 198, 134, 25, 74, 168, 15, 49, 228, 196, 86, 234, 111, 138, + 68, 234, 95, 25, 235, 81, 241, 208, 47, 184, 227, 193, 12, 172, 246, 161, 191, 163, 38, 75, + 28, 33, 57, 59, 193, 70, 235, 104, 98, 190, 1, 106, 113, 224, 156, 100, 44, 102, 19, 35, + 122, 188, 72, 79, 72, 94, 228, 119, 6, 88, 16, 141, 109, 226, 72, 146, 162, 232, 64, 83, + 217, 14, 97, 170, 215, 144, 134, 22, 50, 146, 60, 129, 198, 46, 135, 200, 178, 163, 124, + 57, 122, 209, 115, 162, 137, 91, 230, 104, 174, 143, 44, 109, 184, 115, 52, 108, 50, 182, + 210, 21, 77, 241, 77, 71, 238, 38, 62, 72, 60, 126, 67, 246, 30, 104, 59, 133, 91, 126, + 118, 206, 159, 192, + ]; + let expected_pk_bytes = [ + 119, 254, 34, 234, 204, 15, 174, 243, 92, 115, 150, 231, 206, 164, 71, 139, 213, 50, 94, + 194, 28, 121, 191, 247, 202, 174, 202, 152, 190, 237, 185, 47, 210, 134, 43, 25, 116, 38, + 235, 77, 200, 192, 178, 168, 197, 157, 110, 23, 210, 229, 62, 48, 154, 229, 161, 210, 105, + 122, 76, 74, 243, 207, 98, 159, 241, 185, 168, 136, 169, 140, 72, 131, 71, 216, 231, 89, + 73, 40, 5, 79, 119, 59, 251, 145, 171, 192, 242, 228, 72, 145, 190, 104, 129, 229, 171, + 255, 176, 141, 108, 192, 201, 185, 84, 102, 39, 119, 30, 173, 171, 154, 250, 90, 75, 193, + 146, 50, 100, 105, 112, 62, 191, 56, 255, 18, 161, 43, 140, 245, 251, 249, 110, 38, 145, + 126, 106, 188, 15, 29, 68, 55, 188, 172, 108, 56, 82, 125, 88, 109, 249, 115, 65, 197, 219, + 40, 49, 143, 142, 40, 152, 110, 89, 198, 119, 87, 233, 198, 52, 76, 62, 3, 4, 205, 134, + 225, 193, 137, 188, 83, 203, 131, 187, 91, 51, 103, 175, 198, 85, 244, 48, 216, 205, 201, + 31, 37, 175, 51, 38, 97, 201, 125, 49, 86, 187, 122, 119, 245, 199, 108, 168, 31, 122, 83, + 212, 166, 85, 65, 125, 217, 250, 15, 168, 191, 147, 32, 70, 15, 156, 174, 121, 26, 67, 243, + 240, 152, 41, 225, 187, 246, 232, 93, 240, 247, 143, 172, 102, 157, 173, 20, 46, 193, 158, + 22, 236, 170, 154, 203, 93, 71, 234, 103, 242, 103, 142, 224, 128, 254, 80, 133, 121, 49, + 138, 8, 109, 199, 23, 33, 191, 252, 45, 126, 67, 14, 198, 254, 128, 137, 149, 3, 225, 124, + 89, 157, 97, 65, 196, 77, 173, 197, 95, 240, 194, 87, 5, 24, 43, 192, 79, 14, 209, 40, 120, + 140, 100, 80, 3, 55, 75, 114, 152, 248, 241, 235, 37, 113, 117, 248, 215, 180, 245, 231, + 134, 32, 42, 177, 47, 179, 35, 233, 54, 130, 153, 217, 103, 112, 54, 177, 145, 153, 84, + 240, 54, 240, 240, 232, 79, 218, 24, 239, 32, 49, 215, 55, 2, 68, 9, 142, 198, 188, 113, + 75, 175, 12, 114, 100, 149, 1, 77, 103, 10, 26, 92, 232, 202, 3, 74, 157, 179, 193, 0, 158, + 180, 214, 155, 141, 152, 27, 243, 170, 140, 77, 190, 4, 176, 24, 68, 242, 253, 115, 55, 2, + 68, 138, 233, 138, 113, 155, 52, 191, 207, 35, 66, 252, 47, 146, 25, 57, 212, 66, 18, 235, + 115, 198, 189, 228, 41, 90, 201, 169, 108, 16, 144, 209, 96, 6, 210, 56, 147, 107, 135, 51, + 197, 188, 10, 186, 70, 135, 230, 238, 40, 245, 34, 115, 14, 138, 155, 37, 211, 184, 87, 5, + 88, 140, 232, 211, 239, 197, 230, 234, 166, 124, 59, 231, 125, 118, 52, 74, 184, 138, 202, + 220, 45, 72, 187, 46, 187, 107, 242, 64, 197, 142, 131, 197, 173, 7, 113, 140, 231, 6, 220, + 65, 174, 147, 100, 164, 57, 53, 253, 6, 104, 238, 70, 152, 21, 73, 196, 23, 216, 139, 115, + 214, 197, 46, 146, 102, 9, 137, 137, 48, 32, 81, 163, 136, 51, 246, 163, 233, 158, 163, + 212, 192, 31, 183, 228, 110, 7, 109, 27, 40, 175, 68, 118, 53, 171, 185, 115, 165, 157, + 253, 193, 163, 169, 87, 224, 131, 214, 71, 85, 225, 1, 30, 65, 51, 31, 84, 117, 59, 222, + 107, 228, 158, 94, 198, 219, 43, 206, 151, 218, 186, 167, 53, 171, 154, 239, 1, 164, 130, + 104, 161, 135, 53, 74, 56, 84, 41, 98, 49, 252, 210, 130, 98, 146, 94, 107, 105, 205, 5, + 143, 158, 146, 34, 150, 54, 213, 214, 143, 137, 251, 248, 200, 46, 150, 32, 70, 138, 191, + 129, 134, 136, 181, 36, 148, 241, 229, 29, 46, 172, 94, 140, 237, 251, 26, 163, 116, 31, + 122, 15, 149, 58, 90, 147, 13, 20, 153, 74, 55, 131, 165, 191, 128, 57, 34, 214, 125, 57, + 176, 1, 246, 79, 144, 61, 150, 78, 26, 39, 163, 111, 22, 29, 130, 169, 233, 182, 254, 144, + 70, 43, 77, 105, 200, 172, 81, 145, 157, 226, 48, 78, 243, 138, 232, 75, 40, 113, 36, 205, + 154, 2, 118, 250, 131, 28, 110, 48, 125, 237, 123, 197, 147, 164, 174, 116, 183, 109, 235, + 154, 136, 172, 250, 43, 215, 249, 142, 228, 51, 137, 65, 34, 31, 98, 230, 253, 220, 77, 23, + 21, 158, 100, 196, 38, 216, 105, 233, 14, 74, 61, 161, 234, 160, 144, 253, 179, 187, 115, + 194, 129, 13, 139, 245, 166, 51, 104, 197, 223, 38, 20, 88, 96, 38, 169, 246, 2, 208, 124, + 21, 143, 146, 238, 76, 147, 170, 211, 193, 45, 12, 128, 201, 158, 173, 28, 202, 175, 131, + 67, 167, 143, 140, 29, 173, 209, 199, 109, 169, 112, 232, 47, 251, 33, 245, 25, 151, 11, + 226, 50, 30, 202, 53, 220, 234, 181, 217, 178, 150, 189, 221, 84, 196, 15, 105, 205, 3, + 149, 20, 211, 199, 115, 164, 155, 110, 75, 22, 141, 55, 27, 168, 237, 133, 149, 160, 79, + 222, 25, 228, 112, 193, 72, 128, 129, 84, 238, 80, 113, 250, 123, 116, 148, 81, 179, 12, + 240, 37, 51, 203, 16, 147, 11, 244, 44, 14, 238, 140, 160, 135, 73, 225, 140, 105, 159, 87, + 207, 32, 123, 236, 132, 50, 167, 215, 5, 94, 129, 123, 12, 138, 106, 232, 190, 162, 200, + 141, 95, 94, 135, 15, 49, 30, 150, 251, 10, 194, 110, 77, 35, 103, 173, 184, 21, 185, 179, + 127, 107, 72, 96, 240, 153, 117, 145, 159, 33, 29, 166, 222, 126, 251, 51, 116, 75, 41, + 126, 255, 67, 117, 131, 92, 4, 101, 60, 31, 64, 107, 115, 146, 223, 83, 151, 63, 207, 238, + 80, 253, 94, 1, 221, 78, 28, 214, 42, 33, 168, 167, 137, 44, 236, 50, 9, 26, 116, 87, 134, + 155, 125, 220, 220, 248, 27, 187, 192, 219, 17, 210, 199, 250, 179, 49, 109, 147, 211, 60, + 129, 79, 157, 225, 126, 242, 134, 73, 83, 197, 239, 199, 252, 41, 220, 30, 154, 241, 92, 7, + 169, 168, 7, 215, 37, 95, 211, 163, 4, 178, 200, 169, 153, 64, 112, 66, 19, 107, 248, 29, + 238, 215, 84, 40, 45, 105, 88, 137, 58, 130, 57, 88, 7, 212, 80, 177, 249, 77, 2, 68, 102, + 150, 10, 124, 56, 200, 151, 191, 230, 118, 249, 182, 30, 46, 177, 109, 105, 225, 220, 169, + 238, 185, 116, 235, 6, 75, 100, 156, 121, 207, 172, 67, 57, 73, 96, 245, 65, 179, 207, 246, + 42, 34, 151, 161, 143, 55, 183, 186, 86, 202, 72, 111, 186, 75, 153, 85, 146, 119, 253, 51, + 61, 201, 128, 239, 89, 116, 144, 223, 69, 141, 104, 57, 87, 90, 158, 177, 27, 120, 46, 10, + 214, 31, 226, 196, 252, 40, 99, 192, 145, 164, 11, 11, 107, 42, 164, 65, 123, 177, 167, 38, + 8, 155, 6, 201, 142, 33, 6, 178, 231, 198, 51, 24, 146, 24, 38, 3, 136, 95, 42, 221, 135, + 191, 250, 128, 48, 174, 206, 129, 228, 32, 109, 63, 217, 87, 166, 128, 217, 34, 85, 223, + 176, 55, 174, 42, 99, 216, 185, 60, 107, 51, 10, 69, 91, 204, 18, 65, 228, 230, 55, 200, + 212, 178, 104, 181, 154, 211, 97, 173, 7, 208, 214, 155, 96, 229, 101, 221, 67, 247, 26, 0, + 163, 138, 223, 90, 169, 9, 94, 251, 124, 220, 123, 219, 235, 92, 22, 133, 242, 179, 80, 40, + 225, 61, 146, 211, 48, 218, 21, 53, 56, 60, 137, 146, 88, 48, 111, 13, 95, 231, 132, 134, + 230, 54, 235, 86, 54, 107, 107, 81, 107, 28, 92, 5, 34, 149, 186, 222, 136, 245, 86, 74, + 178, 231, 180, 245, 109, 255, 157, 197, 180, 116, 81, 134, 233, 253, 113, 204, 159, 77, 14, + 173, 223, 194, 213, 30, 134, 36, 235, 239, 26, 79, 142, 223, 98, 149, 47, 94, 160, 7, 15, + 110, 215, 21, 207, 52, 54, 144, 89, 233, 63, 208, 147, 130, 129, 36, 184, 171, 215, 245, + 226, 93, 225, 121, 102, 58, 121, 249, 248, 177, 11, 55, 53, 31, 181, 90, 2, 235, 6, 62, + 187, 103, 140, 73, 153, 231, 161, 189, 233, 77, 130, 65, 145, 109, 38, 139, 125, 23, 227, + 201, 40, 203, 157, 154, 113, 28, 194, 124, 162, 89, 198, 17, 217, 162, 147, 124, 94, 39, + 98, 228, 190, 133, 23, 195, 34, 16, 44, 101, 178, 154, 209, 170, 250, 85, 76, 155, 81, 38, + 246, 112, 33, 229, 65, 66, 170, 1, 159, 215, 110, 175, 158, 9, 4, 116, 131, 54, 183, 243, + 145, 111, 209, 129, 235, 41, 210, 93, 199, 13, 133, 231, 206, 236, 240, 169, 45, 231, 130, + 236, 239, 30, 116, 5, 14, 201, 241, 138, 23, 241, 198, 201, 170, 131, 78, 142, 2, 59, 51, + 120, 31, 84, 235, 144, 62, 139, 208, 214, 115, 86, 98, 247, 210, 165, 48, 191, 68, 202, + 231, 15, 43, 45, 142, 243, 161, 148, 132, 224, 13, 234, 36, 46, 201, 88, 189, 163, 190, + 199, 82, 98, 73, 82, 71, 70, 236, 212, 117, 94, 123, 18, 111, 30, 233, 147, 207, 155, 220, + 113, 236, 87, 35, 87, 210, 104, 102, 52, 189, 33, 195, 181, 62, 156, 165, 117, 26, 180, + 197, 149, 42, 175, 107, 3, 121, 182, 222, 32, 238, 124, 148, 167, 195, 32, 42, 249, 197, + 143, 211, 115, 238, 125, 219, 106, 234, 106, 246, 96, 106, 112, 26, 190, 245, 182, 86, 247, + 151, 120, 54, 120, 100, 219, 58, 8, 197, 172, 251, 17, 56, 107, 233, 220, 28, 203, 202, 56, + 115, 233, 228, 184, 2, 157, 73, 161, 114, 199, 75, 20, 196, 145, 55, 186, 189, 125, 44, + 249, 89, 206, 23, 60, 86, 81, 54, 94, 212, 196, 177, 236, 126, 88, 49, 206, 130, 171, 125, + 44, 101, 48, 245, 158, 187, 79, 232, 36, 42, 50, 238, 162, 244, 91, 217, 218, 34, 145, 255, + 32, 203, 239, 26, 236, 119, 130, 89, 142, 205, 125, 147, 238, 113, 153, 134, 22, 225, 123, + 104, 144, 230, 10, 103, 239, 236, 47, 98, 162, 241, 38, 157, 158, 254, 225, 171, 70, 103, + 203, 14, 3, 141, 59, 64, 250, 203, 161, 29, 168, 72, 110, 138, 43, 166, 106, 232, 117, 218, + 110, 165, 36, 26, 112, 88, 51, 45, 169, 5, 164, 31, 122, 92, 34, 199, 228, 239, 146, 102, + 30, 178, 102, 101, 181, 41, 127, 42, 156, 252, 250, 0, 121, 120, 15, 62, 60, 19, 130, 185, + 118, 33, 77, 168, 96, 200, 98, 10, 191, 96, 192, 111, 107, 156, 119, 180, 206, 58, 18, 34, + 248, 33, 235, 167, 146, 151, 119, 151, 23, 243, 194, 247, 148, 253, 168, 76, 89, 82, 80, + 55, 127, 236, 48, 173, 114, 131, 155, 147, 249, 239, 179, 145, 20, 16, 76, 161, 46, 13, + 185, 57, 130, 137, 84, 110, 244, 44, 32, 160, 59, 33, 56, 64, 69, 91, 155, 141, 33, 246, + 139, 117, 102, 41, 93, 83, 207, 151, 124, 112, 61, 246, 164, 36, 234, 98, 191, 27, 251, + 149, 42, 35, 99, 236, 133, 242, 81, 159, 208, 150, 19, 45, 250, 172, 195, 89, 100, 66, 208, + 107, 2, 6, 173, 115, 133, 138, 158, 108, 116, 83, 47, 14, + ]; + let expected_sig_bytes = [ + 239, 190, 184, 176, 174, 61, 103, 122, 187, 184, 112, 98, 191, 197, 224, 124, 21, 181, 91, + 89, 86, 159, 117, 159, 65, 31, 198, 29, 80, 216, 171, 220, 184, 22, 38, 44, 77, 81, 9, 161, + 130, 117, 69, 26, 180, 8, 101, 188, 145, 208, 135, 201, 242, 145, 46, 254, 47, 128, 235, + 173, 130, 176, 206, 56, 200, 138, 218, 127, 41, 190, 129, 78, 61, 17, 70, 163, 48, 42, 191, + 148, 32, 23, 245, 150, 215, 179, 113, 226, 250, 154, 215, 3, 150, 110, 86, 6, 49, 75, 108, + 144, 93, 168, 118, 55, 26, 242, 40, 186, 109, 121, 84, 78, 155, 23, 149, 115, 226, 129, + 197, 163, 63, 132, 71, 25, 49, 206, 129, 89, 234, 91, 130, 214, 183, 182, 95, 31, 3, 201, + 227, 166, 208, 153, 106, 97, 98, 83, 32, 186, 128, 161, 131, 191, 223, 210, 195, 56, 156, + 56, 220, 228, 71, 163, 111, 140, 120, 167, 129, 104, 212, 191, 254, 241, 45, 212, 133, 65, + 47, 127, 137, 57, 105, 29, 77, 120, 171, 93, 168, 182, 171, 206, 35, 55, 129, 92, 26, 211, + 123, 157, 110, 207, 248, 43, 165, 131, 160, 99, 185, 17, 163, 135, 137, 194, 109, 119, 246, + 146, 212, 46, 254, 197, 55, 36, 191, 181, 17, 238, 192, 39, 96, 155, 126, 121, 85, 49, 131, + 3, 190, 120, 10, 106, 76, 251, 51, 98, 16, 45, 37, 3, 125, 243, 69, 240, 75, 140, 74, 149, + 210, 174, 60, 200, 252, 156, 48, 117, 193, 181, 73, 142, 199, 78, 137, 64, 168, 208, 197, + 218, 232, 195, 199, 207, 31, 32, 45, 20, 99, 53, 65, 6, 104, 120, 26, 117, 66, 101, 16, 81, + 99, 38, 84, 40, 234, 194, 192, 1, 178, 124, 197, 151, 158, 107, 246, 202, 87, 75, 127, 239, + 211, 226, 168, 190, 119, 156, 121, 48, 28, 253, 145, 41, 163, 167, 80, 211, 163, 214, 183, + 191, 215, 36, 170, 67, 49, 195, 128, 239, 75, 211, 246, 167, 38, 226, 117, 56, 35, 49, 215, + 234, 161, 147, 68, 108, 35, 242, 203, 169, 221, 225, 116, 253, 76, 91, 242, 219, 197, 144, + 169, 187, 3, 0, 252, 133, 200, 116, 94, 239, 25, 82, 107, 45, 127, 211, 114, 114, 10, 42, + 101, 202, 206, 206, 227, 193, 246, 26, 152, 220, 228, 241, 60, 34, 68, 118, 48, 171, 55, + 204, 128, 67, 77, 33, 123, 25, 234, 81, 216, 156, 233, 175, 122, 217, 230, 71, 120, 160, + 107, 47, 103, 218, 240, 138, 3, 102, 1, 42, 245, 248, 39, 218, 20, 203, 175, 158, 245, 20, + 43, 39, 189, 51, 144, 173, 68, 58, 131, 96, 53, 7, 221, 57, 241, 28, 174, 14, 29, 158, 152, + 86, 84, 160, 70, 15, 94, 144, 82, 246, 154, 32, 120, 236, 53, 253, 87, 74, 84, 134, 130, + 220, 86, 170, 138, 132, 20, 4, 17, 228, 114, 239, 128, 111, 109, 247, 11, 32, 51, 150, 252, + 99, 106, 96, 250, 166, 41, 217, 57, 242, 53, 125, 60, 85, 2, 254, 188, 2, 95, 163, 7, 210, + 158, 11, 236, 171, 167, 69, 191, 125, 154, 1, 63, 16, 31, 218, 62, 215, 82, 89, 21, 68, + 100, 43, 105, 13, 138, 30, 40, 105, 13, 121, 112, 31, 197, 210, 99, 43, 204, 164, 99, 2, + 149, 10, 235, 184, 223, 254, 191, 2, 38, 88, 245, 160, 185, 171, 124, 10, 97, 54, 168, 131, + 12, 47, 214, 194, 188, 229, 151, 67, 55, 205, 7, 139, 74, 11, 2, 164, 183, 6, 241, 51, 158, + 233, 208, 194, 24, 2, 172, 29, 90, 251, 16, 45, 30, 144, 54, 105, 131, 195, 136, 218, 155, + 130, 127, 128, 80, 58, 23, 172, 98, 97, 111, 151, 52, 80, 212, 140, 36, 121, 153, 193, 152, + 87, 43, 21, 139, 211, 189, 170, 153, 156, 182, 194, 229, 85, 67, 230, 30, 26, 34, 44, 243, + 223, 31, 219, 230, 147, 103, 159, 130, 18, 192, 35, 2, 190, 251, 146, 48, 216, 231, 136, + 49, 239, 176, 95, 186, 126, 213, 5, 139, 110, 250, 133, 91, 165, 245, 41, 253, 244, 143, + 138, 84, 81, 99, 122, 234, 198, 115, 188, 147, 144, 26, 97, 3, 131, 58, 103, 117, 90, 99, + 230, 118, 113, 31, 46, 196, 247, 114, 188, 239, 217, 108, 117, 6, 55, 254, 226, 18, 49, 46, + 209, 11, 140, 207, 10, 141, 27, 20, 236, 118, 6, 101, 72, 21, 173, 193, 122, 231, 98, 175, + 10, 71, 124, 184, 220, 147, 93, 160, 196, 162, 118, 160, 35, 251, 164, 221, 99, 210, 107, + 89, 11, 148, 109, 55, 104, 193, 121, 27, 101, 222, 62, 142, 226, 236, 134, 215, 107, 184, + 0, 89, 207, 68, 246, 250, 48, 178, 62, 245, 162, 69, 214, 97, 93, 228, 209, 251, 27, 84, + 117, 248, 172, 86, 80, 132, 115, 40, 8, 60, 181, 34, 237, 187, 139, 12, 247, 17, 85, 95, + 205, 115, 30, 139, 188, 4, 24, 87, 168, 132, 15, 197, 121, 227, 237, 4, 201, 218, 255, 88, + 214, 27, 133, 97, 191, 255, 67, 190, 20, 214, 31, 4, 16, 147, 12, 252, 90, 158, 71, 240, + 207, 211, 104, 175, 14, 122, 202, 183, 142, 136, 85, 240, 49, 87, 207, 127, 103, 230, 204, + 66, 217, 149, 46, 62, 11, 194, 60, 29, 62, 77, 137, 169, 186, 11, 47, 241, 158, 231, 125, + 152, 248, 111, 19, 41, 48, 36, 90, 113, 214, 119, 57, 175, 137, 204, 99, 131, 13, 2, 247, + 82, 29, 57, 19, 199, 127, 81, 122, 157, 139, 71, 115, 158, 87, 116, 105, 235, 235, 153, + 224, 221, 136, 14, 52, 205, 23, 31, 250, 237, 164, 78, 84, 83, 93, 222, 21, 158, 102, 116, + 165, 60, 111, 36, 177, 180, 182, 89, 138, 244, 69, 103, 40, 194, 184, 137, 74, 236, 187, + 123, 109, 45, 253, 68, 70, 205, 238, 254, 192, 34, 149, 251, 211, 162, 90, 126, 235, 99, + 146, 183, 153, 234, 171, 244, 170, 187, 22, 42, 50, 210, 96, 142, 80, 203, 194, 45, 44, + 141, 47, 49, 50, 99, 225, 46, 176, 69, 153, 100, 207, 214, 88, 237, 110, 139, 123, 198, 84, + 165, 62, 47, 79, 89, 28, 164, 180, 20, 33, 54, 58, 202, 103, 239, 106, 99, 103, 157, 53, + 97, 48, 2, 12, 36, 87, 100, 137, 219, 249, 219, 55, 34, 249, 36, 142, 245, 240, 178, 116, + 71, 73, 206, 209, 45, 71, 28, 142, 183, 35, 5, 124, 230, 243, 77, 89, 41, 180, 196, 149, + 163, 179, 100, 191, 81, 254, 158, 127, 194, 54, 92, 241, 34, 77, 126, 104, 143, 18, 77, 87, + 19, 160, 252, 195, 162, 222, 30, 201, 202, 253, 44, 35, 37, 100, 138, 129, 174, 216, 55, + 73, 75, 145, 92, 67, 234, 173, 61, 121, 0, 148, 42, 104, 105, 242, 75, 237, 81, 196, 79, + 106, 178, 64, 102, 101, 216, 22, 198, 178, 101, 19, 74, 59, 8, 138, 103, 200, 37, 220, 46, + 154, 186, 219, 91, 243, 35, 182, 229, 212, 69, 212, 131, 122, 89, 86, 25, 194, 51, 224, + 201, 148, 186, 73, 226, 183, 219, 250, 176, 98, 173, 155, 225, 69, 52, 160, 80, 230, 54, + 220, 55, 229, 159, 176, 76, 77, 213, 62, 78, 131, 11, 233, 86, 224, 32, 190, 120, 81, 148, + 144, 73, 84, 115, 32, 14, 231, 239, 172, 252, 166, 23, 163, 13, 200, 223, 26, 92, 117, 29, + 101, 16, 39, 110, 219, 250, 108, 45, 48, 141, 139, 50, 251, 176, 149, 254, 131, 94, 191, + 44, 45, 75, 231, 108, 226, 101, 181, 234, 30, 134, 75, 6, 208, 188, 114, 58, 203, 255, 141, + 54, 167, 117, 188, 160, 204, 65, 233, 105, 215, 51, 22, 156, 37, 53, 245, 242, 123, 163, + 234, 157, 122, 140, 106, 76, 148, 0, 202, 31, 172, 75, 23, 169, 134, 185, 194, 201, 220, + 169, 131, 205, 219, 17, 71, 176, 177, 168, 44, 66, 129, 234, 82, 172, 153, 33, 74, 162, + 101, 247, 100, 70, 94, 140, 164, 185, 14, 145, 126, 245, 226, 8, 218, 212, 116, 130, 202, + 106, 184, 84, 13, 140, 171, 206, 65, 161, 16, 40, 222, 88, 217, 84, 77, 226, 186, 32, 199, + 5, 235, 12, 238, 131, 121, 252, 178, 66, 153, 229, 107, 58, 110, 211, 176, 105, 136, 51, + 80, 72, 1, 75, 66, 39, 82, 34, 6, 107, 128, 12, 149, 121, 50, 165, 92, 170, 186, 86, 143, + 66, 233, 71, 181, 32, 207, 201, 96, 123, 112, 34, 24, 196, 150, 180, 206, 27, 135, 141, 25, + 58, 177, 84, 39, 23, 213, 232, 68, 93, 13, 49, 10, 139, 125, 56, 212, 67, 1, 191, 79, 169, + 102, 247, 241, 102, 145, 27, 104, 159, 177, 148, 76, 72, 77, 131, 61, 212, 127, 189, 26, 6, + 248, 251, 87, 224, 16, 75, 243, 69, 93, 140, 9, 19, 210, 132, 50, 159, 147, 143, 104, 33, + 91, 118, 139, 60, 83, 203, 101, 110, 155, 219, 155, 110, 30, 155, 139, 56, 163, 44, 133, + 131, 113, 233, 76, 77, 243, 6, 169, 84, 35, 246, 36, 120, 228, 12, 163, 0, 248, 184, 59, + 114, 60, 220, 81, 124, 154, 68, 254, 21, 145, 143, 132, 245, 54, 236, 3, 202, 33, 44, 133, + 84, 28, 72, 182, 84, 212, 254, 42, 129, 24, 4, 155, 233, 223, 139, 194, 99, 141, 55, 49, + 166, 132, 46, 68, 63, 148, 161, 32, 239, 109, 242, 154, 28, 177, 149, 101, 192, 136, 137, + 170, 121, 239, 40, 103, 54, 112, 9, 245, 110, 211, 26, 86, 165, 22, 147, 112, 67, 126, 162, + 73, 83, 197, 20, 68, 185, 227, 22, 196, 2, 230, 0, 6, 149, 33, 6, 107, 191, 209, 173, 162, + 112, 159, 150, 144, 195, 196, 53, 85, 87, 69, 230, 27, 255, 47, 229, 145, 180, 236, 154, + 183, 77, 33, 99, 124, 184, 126, 238, 177, 16, 124, 184, 109, 240, 207, 147, 81, 110, 178, + 79, 59, 190, 216, 147, 149, 91, 214, 35, 51, 53, 31, 35, 154, 134, 6, 54, 147, 49, 53, 174, + 44, 51, 101, 22, 30, 39, 99, 213, 205, 26, 107, 210, 145, 206, 180, 24, 0, 47, 211, 253, + 29, 18, 106, 136, 177, 8, 184, 121, 135, 150, 132, 3, 124, 13, 53, 179, 249, 239, 239, 18, + 194, 37, 58, 60, 86, 32, 46, 255, 227, 11, 231, 31, 153, 48, 234, 195, 21, 122, 9, 132, 21, + 60, 207, 131, 235, 83, 144, 52, 132, 212, 222, 50, 119, 21, 80, 128, 214, 11, 78, 216, 2, + 104, 123, 21, 246, 211, 15, 34, 67, 207, 78, 139, 50, 142, 115, 190, 57, 50, 242, 3, 141, + 148, 137, 161, 144, 209, 145, 191, 46, 179, 128, 125, 255, 43, 103, 180, 249, 218, 36, 244, + 189, 156, 217, 163, 29, 8, 55, 236, 206, 47, 191, 127, 240, 135, 69, 243, 164, 239, 218, 4, + 158, 141, 157, 164, 219, 24, 186, 237, 87, 218, 128, 253, 63, 236, 138, 141, 186, 96, 107, + 228, 82, 238, 8, 135, 236, 145, 100, 228, 254, 178, 200, 65, 204, 99, 36, 140, 76, 54, 227, + 255, 208, 76, 81, 71, 44, 31, 181, 108, 99, 165, 203, 245, 36, 42, 18, 47, 211, 220, 208, + 108, 215, 103, 44, 33, 170, 218, 40, 232, 105, 160, 154, 132, 130, 71, 175, 203, 223, 50, + 61, 79, 89, 92, 102, 230, 162, 65, 89, 100, 81, 19, 185, 143, 229, 226, 119, 208, 64, 190, + 204, 4, 185, 38, 164, 206, 215, 13, 203, 29, 240, 230, 68, 39, 54, 232, 89, 138, 44, 84, + 12, 97, 67, 253, 22, 63, 97, 238, 67, 30, 231, 131, 141, 139, 234, 141, 230, 55, 158, 188, + 55, 32, 11, 58, 18, 153, 189, 145, 55, 76, 102, 181, 116, 20, 113, 103, 228, 198, 51, 136, + 150, 120, 24, 46, 40, 13, 13, 120, 240, 179, 62, 93, 115, 21, 135, 226, 47, 108, 123, 45, + 22, 221, 240, 58, 95, 251, 1, 90, 135, 44, 242, 9, 166, 236, 236, 98, 188, 113, 11, 57, 59, + 14, 213, 246, 236, 197, 251, 136, 188, 56, 209, 147, 95, 197, 208, 113, 147, 13, 246, 104, + 136, 115, 223, 221, 149, 110, 250, 175, 178, 57, 95, 245, 156, 55, 200, 6, 36, 147, 119, + 58, 113, 138, 194, 220, 100, 238, 120, 225, 160, 57, 54, 234, 254, 165, 96, 131, 218, 186, + 138, 63, 29, 244, 197, 96, 215, 141, 136, 5, 211, 123, 142, 239, 123, 54, 130, 156, 21, + 214, 169, 241, 75, 57, 250, 247, 65, 87, 129, 205, 144, 239, 100, 83, 16, 169, 141, 209, + 87, 55, 240, 246, 31, 108, 161, 226, 137, 82, 207, 133, 116, 166, 207, 81, 105, 54, 195, + 251, 236, 23, 15, 104, 241, 91, 23, 77, 214, 228, 42, 219, 211, 229, 200, 80, 85, 99, 51, + 170, 6, 21, 235, 0, 98, 113, 50, 160, 181, 222, 34, 73, 75, 224, 150, 78, 39, 185, 134, 23, + 95, 57, 218, 198, 248, 178, 213, 51, 92, 33, 211, 35, 158, 211, 81, 10, 118, 150, 158, 230, + 99, 120, 104, 1, 34, 61, 203, 144, 164, 21, 190, 193, 228, 99, 153, 209, 217, 194, 96, 191, + 106, 251, 100, 247, 88, 166, 33, 156, 2, 49, 113, 84, 75, 231, 97, 99, 204, 235, 172, 122, + 244, 2, 105, 34, 73, 236, 14, 222, 67, 141, 110, 174, 198, 221, 228, 252, 167, 3, 197, 36, + 62, 156, 137, 49, 18, 38, 21, 33, 110, 242, 119, 225, 126, 24, 134, 85, 245, 38, 247, 204, + 154, 39, 205, 44, 132, 8, 131, 153, 85, 124, 35, 165, 20, 158, 175, 222, 165, 76, 136, 150, + 60, 52, 111, 245, 217, 37, 166, 234, 234, 48, 92, 176, 87, 134, 155, 22, 252, 103, 156, + 255, 121, 238, 50, 246, 6, 98, 134, 60, 230, 83, 33, 21, 104, 42, 231, 47, 23, 198, 229, + 95, 244, 137, 172, 246, 250, 145, 116, 127, 117, 246, 4, 213, 234, 204, 152, 96, 104, 242, + 223, 143, 223, 109, 179, 1, 240, 135, 117, 141, 245, 232, 136, 30, 202, 216, 127, 160, 114, + 152, 91, 55, 186, 157, 174, 142, 40, 165, 39, 10, 217, 184, 173, 165, 37, 40, 78, 251, 66, + 68, 218, 189, 220, 144, 112, 186, 4, 198, 115, 162, 141, 29, 87, 170, 142, 222, 129, 72, + 187, 179, 64, 149, 246, 243, 41, 228, 220, 207, 33, 249, 122, 93, 3, 24, 188, 255, 248, + 142, 118, 117, 191, 215, 109, 233, 27, 131, 127, 62, 247, 246, 140, 163, 87, 26, 59, 240, + 240, 190, 14, 36, 81, 81, 80, 137, 63, 142, 200, 158, 11, 173, 113, 217, 71, 182, 122, 112, + 10, 168, 85, 127, 250, 15, 117, 9, 220, 250, 231, 40, 17, 150, 45, 75, 37, 174, 195, 178, + 166, 236, 66, 171, 126, 25, 108, 65, 71, 221, 115, 158, 185, 84, 106, 141, 24, 145, 252, + 248, 204, 222, 99, 81, 193, 175, 84, 93, 48, 85, 251, 144, 125, 184, 95, 67, 31, 79, 58, + 192, 230, 126, 179, 150, 13, 35, 99, 41, 138, 99, 64, 73, 113, 18, 227, 195, 48, 139, 156, + 227, 189, 25, 52, 215, 38, 131, 57, 130, 5, 23, 43, 244, 84, 192, 94, 24, 132, 148, 102, + 196, 61, 163, 188, 114, 105, 104, 99, 190, 157, 61, 49, 157, 24, 33, 82, 11, 233, 255, 142, + 52, 203, 43, 60, 62, 142, 128, 196, 47, 127, 164, 9, 185, 122, 194, 183, 43, 135, 45, 47, + 28, 220, 121, 230, 235, 45, 80, 213, 246, 179, 105, 10, 81, 253, 186, 206, 130, 146, 95, + 35, 8, 247, 52, 24, 147, 36, 90, 162, 172, 32, 220, 156, 141, 101, 24, 150, 105, 130, 243, + 36, 184, 121, 11, 255, 173, 39, 236, 61, 114, 225, 233, 23, 198, 14, 12, 160, 50, 241, 170, + 180, 238, 69, 6, 206, 37, 230, 19, 96, 176, 92, 249, 14, 88, 208, 44, 112, 67, 91, 204, + 241, 238, 191, 223, 126, 127, 131, 146, 229, 55, 205, 65, 231, 83, 117, 182, 89, 124, 150, + 234, 141, 174, 145, 182, 113, 137, 176, 198, 23, 158, 19, 97, 223, 246, 221, 244, 254, 230, + 109, 157, 198, 239, 242, 28, 181, 56, 131, 255, 233, 187, 178, 26, 63, 192, 198, 154, 20, + 38, 8, 224, 65, 104, 225, 78, 60, 156, 71, 174, 20, 48, 213, 46, 28, 166, 246, 109, 250, + 156, 186, 211, 68, 233, 249, 253, 30, 178, 26, 5, 44, 76, 109, 19, 183, 221, 27, 71, 147, + 1, 20, 25, 75, 215, 177, 216, 163, 254, 119, 223, 175, 12, 155, 26, 105, 215, 229, 32, 6, + 84, 213, 17, 90, 166, 69, 55, 88, 34, 197, 60, 238, 157, 9, 32, 164, 146, 123, 242, 160, + 184, 73, 146, 14, 40, 23, 135, 66, 16, 138, 52, 43, 49, 87, 254, 253, 226, 237, 88, 43, + 187, 83, 106, 69, 71, 162, 18, 90, 210, 229, 29, 91, 120, 157, 122, 73, 82, 220, 138, 25, + 149, 158, 100, 136, 129, 13, 160, 163, 100, 232, 84, 239, 153, 101, 81, 175, 161, 206, 176, + 120, 20, 188, 51, 131, 162, 238, 14, 50, 188, 117, 184, 199, 123, 101, 163, 175, 68, 252, + 158, 28, 90, 223, 69, 230, 21, 7, 78, 108, 206, 224, 70, 133, 42, 79, 179, 11, 143, 179, + 221, 251, 36, 9, 96, 179, 36, 247, 37, 151, 255, 107, 138, 126, 5, 148, 116, 12, 243, 91, + 236, 144, 171, 171, 86, 255, 19, 19, 248, 230, 134, 43, 92, 146, 91, 105, 221, 50, 175, + 104, 140, 198, 122, 88, 23, 111, 191, 63, 21, 21, 122, 160, 1, 75, 70, 108, 248, 23, 84, + 142, 198, 137, 64, 59, 216, 117, 210, 45, 201, 90, 60, 218, 229, 149, 180, 135, 144, 214, + 56, 67, 228, 104, 233, 210, 226, 30, 255, 235, 237, 227, 214, 233, 90, 247, 198, 137, 236, + 177, 140, 217, 5, 194, 89, 9, 17, 72, 109, 245, 87, 106, 205, 202, 118, 126, 122, 172, 112, + 249, 27, 186, 45, 255, 228, 250, 127, 62, 23, 4, 229, 99, 82, 115, 79, 32, 219, 207, 152, + 152, 156, 40, 70, 198, 221, 221, 47, 40, 101, 167, 136, 9, 98, 244, 100, 59, 199, 7, 246, + 41, 77, 64, 133, 9, 194, 255, 222, 124, 117, 220, 133, 105, 0, 33, 101, 157, 216, 58, 229, + 32, 12, 106, 23, 251, 177, 56, 1, 31, 13, 99, 239, 67, 135, 114, 33, 144, 230, 178, 178, + 224, 188, 106, 217, 24, 169, 248, 158, 118, 119, 111, 6, 186, 78, 67, 181, 90, 11, 59, 214, + 234, 204, 236, 171, 31, 42, 152, 45, 19, 112, 214, 164, 186, 172, 53, 169, 117, 104, 54, + 56, 221, 143, 62, 86, 176, 74, 34, 221, 252, 219, 215, 241, 49, 251, 24, 82, 253, 29, 69, + 108, 155, 217, 227, 239, 8, 154, 162, 1, 24, 41, 58, 80, 134, 155, 238, 26, 203, 241, 250, + 12, 19, 46, 133, 154, 161, 207, 15, 70, 73, 77, 101, 136, 154, 164, 221, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 10, 18, 22, 29, 38, + ]; + assert!(check( + &message, + &sk_bytes, + &expected_pk_bytes, + &expected_sig_bytes + )); + + let message = [ + 218, 62, 121, 208, 218, 114, 55, 83, 38, 233, 172, 174, 110, 249, 177, 124, 114, 40, 118, + 121, 23, 33, 223, 54, 167, 79, 38, 5, 94, 220, 54, 175, 38, 228, 229, 217, 51, 144, 214, 7, + 255, 134, 30, 85, 103, 135, 208, 73, 168, 76, 239, 127, 155, 91, 8, 228, 192, 72, 78, + ]; + let sk_bytes = [ + 23, 178, 175, 197, 3, 146, 2, 23, 99, 85, 17, 220, 25, 223, 158, 77, 54, 27, 114, 162, 130, + 181, 61, 104, 173, 208, 32, 252, 216, 46, 47, 228, 64, 162, 89, 120, 245, 21, 175, 176, + 221, 33, 124, 98, 52, 126, 250, 110, 95, 120, 241, 24, 107, 231, 201, 127, 211, 114, 134, + 244, 2, 218, 250, 59, 206, 124, 52, 22, 60, 159, 51, 25, 17, 197, 188, 50, 74, 125, 61, 52, + 86, 37, 69, 83, 36, 118, 35, 139, 191, 187, 39, 37, 229, 30, 131, 11, 38, 99, 36, 71, 51, + 7, 104, 3, 56, 53, 49, 32, 68, 132, 96, 113, 1, 99, 70, 6, 48, 130, 85, 50, 39, 116, 120, + 81, 112, 36, 19, 0, 135, 5, 40, 131, 51, 85, 4, 17, 104, 117, 117, 48, 3, 18, 17, 115, 83, + 80, 6, 53, 103, 52, 86, 52, 130, 50, 52, 2, 32, 33, 81, 97, 112, 72, 54, 40, 113, 81, 81, + 98, 96, 67, 113, 37, 104, 18, 54, 53, 83, 18, 65, 16, 133, 80, 85, 64, 115, 68, 68, 117, + 103, 119, 70, 85, 24, 34, 101, 129, 22, 115, 67, 39, 51, 129, 82, 4, 98, 22, 104, 112, 132, + 66, 53, 64, 19, 87, 85, 80, 64, 8, 116, 3, 102, 37, 96, 8, 2, 56, 135, 3, 115, 131, 71, 80, + 6, 103, 0, 83, 35, 38, 99, 20, 102, 33, 112, 71, 39, 81, 129, 68, 51, 88, 131, 56, 114, + 128, 6, 112, 99, 71, 20, 80, 82, 102, 128, 6, 129, 96, 102, 17, 129, 38, 81, 100, 82, 64, + 128, 8, 17, 100, 24, 102, 32, 56, 1, 17, 130, 56, 4, 23, 103, 117, 68, 114, 115, 80, 128, + 96, 135, 130, 4, 4, 136, 36, 71, 7, 104, 115, 88, 68, 100, 116, 17, 82, 99, 119, 64, 114, + 82, 115, 135, 116, 103, 34, 96, 40, 39, 35, 86, 99, 55, 102, 22, 133, 24, 19, 88, 102, 114, + 82, 98, 20, 22, 99, 133, 85, 21, 69, 81, 129, 132, 49, 133, 55, 130, 72, 18, 99, 22, 97, + 64, 5, 3, 56, 82, 64, 54, 56, 119, 136, 71, 36, 97, 38, 6, 20, 136, 98, 136, 70, 103, 86, + 24, 64, 50, 69, 56, 113, 22, 3, 7, 133, 5, 80, 135, 102, 117, 115, 32, 134, 36, 8, 6, 68, + 37, 55, 85, 55, 128, 66, 115, 17, 69, 23, 3, 100, 3, 71, 52, 113, 116, 68, 86, 97, 82, 2, + 103, 115, 52, 20, 17, 17, 37, 54, 1, 86, 48, 131, 2, 134, 32, 118, 80, 71, 36, 118, 1, 2, + 115, 113, 51, 128, 135, 116, 35, 64, 32, 136, 120, 19, 81, 88, 39, 85, 80, 51, 19, 70, 103, + 100, 16, 134, 37, 101, 82, 104, 55, 16, 135, 53, 50, 39, 66, 82, 50, 2, 113, 104, 66, 104, + 80, 50, 36, 64, 18, 7, 102, 120, 117, 35, 117, 37, 24, 49, 16, 33, 117, 17, 16, 16, 16, + 119, 55, 51, 40, 38, 115, 33, 40, 82, 64, 65, 135, 87, 120, 56, 69, 18, 87, 67, 64, 55, + 134, 53, 96, 38, 83, 70, 67, 133, 133, 65, 128, 38, 55, 84, 7, 2, 135, 98, 136, 88, 66, 80, + 130, 54, 136, 67, 24, 71, 48, 86, 129, 18, 21, 101, 65, 53, 22, 132, 36, 70, 136, 65, 119, + 55, 133, 53, 56, 55, 83, 130, 8, 1, 134, 119, 54, 97, 37, 81, 3, 82, 40, 104, 101, 103, + 130, 50, 113, 128, 104, 49, 66, 50, 102, 119, 6, 32, 49, 136, 98, 114, 53, 135, 86, 49, 69, + 117, 120, 18, 7, 133, 116, 32, 100, 113, 134, 101, 48, 128, 81, 51, 22, 19, 115, 52, 130, + 102, 8, 82, 33, 22, 132, 133, 112, 40, 84, 128, 55, 119, 87, 99, 117, 64, 71, 81, 103, 72, + 120, 99, 38, 112, 103, 128, 87, 39, 20, 64, 129, 103, 96, 81, 50, 82, 1, 36, 23, 39, 128, + 84, 6, 0, 8, 80, 50, 136, 32, 83, 70, 83, 70, 85, 98, 22, 49, 66, 66, 16, 40, 104, 21, 20, + 34, 7, 83, 82, 5, 65, 40, 52, 100, 67, 54, 65, 35, 3, 40, 112, 50, 55, 37, 56, 56, 98, 96, + 17, 100, 48, 96, 53, 114, 18, 131, 23, 66, 19, 17, 81, 116, 2, 99, 49, 3, 69, 65, 131, 56, + 68, 88, 39, 83, 119, 128, 52, 130, 113, 6, 82, 69, 116, 2, 3, 19, 0, 119, 64, 72, 16, 103, + 99, 117, 53, 134, 40, 17, 136, 7, 129, 72, 133, 32, 4, 136, 54, 66, 129, 21, 100, 39, 70, + 0, 81, 119, 99, 136, 2, 83, 32, 66, 56, 117, 35, 68, 16, 0, 135, 96, 4, 34, 49, 24, 37, 18, + 84, 34, 101, 1, 70, 0, 40, 17, 1, 36, 102, 115, 38, 38, 132, 97, 102, 114, 112, 84, 83, 48, + 16, 21, 53, 23, 119, 116, 129, 53, 130, 69, 39, 21, 104, 32, 64, 118, 130, 21, 70, 116, 50, + 131, 130, 16, 22, 36, 23, 6, 72, 70, 115, 40, 50, 66, 18, 86, 19, 34, 112, 72, 112, 82, 66, + 72, 83, 21, 102, 18, 36, 50, 50, 40, 115, 85, 83, 40, 82, 86, 83, 4, 55, 53, 81, 23, 1, 34, + 82, 68, 4, 98, 135, 53, 0, 99, 81, 72, 136, 38, 82, 82, 98, 16, 7, 132, 132, 100, 64, 134, + 82, 5, 49, 54, 115, 66, 16, 20, 80, 7, 19, 104, 117, 132, 87, 97, 101, 8, 68, 52, 23, 36, + 120, 83, 40, 16, 84, 96, 36, 68, 99, 8, 101, 67, 80, 120, 33, 19, 17, 114, 35, 6, 50, 37, + 118, 87, 135, 0, 7, 18, 33, 132, 68, 18, 67, 65, 6, 113, 117, 33, 82, 49, 97, 33, 56, 101, + 69, 84, 69, 98, 21, 81, 83, 39, 68, 54, 128, 19, 21, 98, 4, 86, 116, 96, 35, 16, 21, 120, + 54, 130, 53, 114, 88, 72, 49, 70, 33, 113, 20, 88, 34, 6, 133, 33, 66, 65, 40, 3, 101, 50, + 3, 72, 51, 132, 85, 0, 33, 6, 120, 51, 86, 21, 112, 66, 33, 5, 39, 80, 67, 104, 23, 64, 85, + 1, 85, 86, 84, 136, 80, 132, 0, 83, 18, 130, 96, 32, 116, 80, 97, 134, 33, 85, 85, 3, 19, + 48, 49, 113, 20, 38, 19, 51, 104, 22, 34, 52, 51, 81, 2, 49, 5, 38, 83, 7, 71, 136, 17, 2, + 33, 51, 104, 99, 67, 129, 135, 1, 103, 20, 19, 19, 39, 8, 36, 54, 81, 87, 4, 135, 114, 66, + 32, 33, 53, 33, 8, 18, 100, 50, 119, 129, 117, 86, 128, 51, 99, 120, 37, 71, 65, 35, 100, + 71, 103, 34, 18, 103, 19, 119, 35, 112, 96, 52, 136, 83, 8, 22, 33, 84, 52, 19, 33, 55, 71, + 55, 112, 51, 96, 32, 82, 34, 2, 81, 88, 68, 7, 120, 4, 22, 35, 18, 120, 17, 115, 86, 48, + 18, 116, 3, 114, 7, 24, 39, 99, 20, 81, 34, 83, 70, 112, 0, 38, 82, 81, 98, 18, 21, 133, + 98, 32, 6, 16, 70, 3, 88, 33, 80, 37, 131, 71, 82, 39, 49, 24, 21, 112, 6, 96, 53, 64, 39, + 69, 49, 69, 37, 35, 132, 83, 8, 7, 83, 17, 7, 64, 87, 24, 133, 68, 136, 64, 33, 56, 19, 6, + 83, 96, 84, 115, 72, 8, 52, 113, 117, 20, 36, 1, 40, 98, 48, 36, 50, 18, 117, 132, 112, 48, + 20, 87, 99, 4, 54, 134, 53, 99, 99, 36, 130, 8, 99, 37, 52, 129, 5, 2, 65, 55, 0, 83, 87, + 114, 132, 130, 113, 17, 85, 118, 81, 39, 100, 51, 50, 96, 87, 103, 36, 84, 103, 8, 103, 99, + 97, 100, 65, 7, 96, 87, 52, 86, 7, 16, 66, 0, 68, 103, 69, 81, 20, 131, 135, 88, 88, 104, + 98, 96, 38, 117, 50, 20, 104, 17, 115, 100, 119, 1, 8, 0, 0, 118, 82, 81, 81, 133, 114, 34, + 131, 85, 19, 4, 52, 49, 81, 51, 102, 84, 17, 7, 1, 51, 112, 120, 39, 68, 8, 83, 35, 39, 56, + 56, 83, 65, 132, 2, 135, 70, 64, 133, 16, 54, 64, 102, 21, 16, 40, 104, 34, 129, 81, 67, 8, + 56, 102, 21, 113, 70, 100, 22, 87, 19, 17, 21, 69, 100, 34, 36, 17, 51, 22, 52, 19, 7, 130, + 82, 22, 5, 115, 113, 69, 98, 23, 112, 21, 8, 84, 52, 82, 102, 65, 5, 1, 35, 87, 98, 35, 54, + 133, 3, 68, 86, 69, 100, 36, 83, 102, 70, 53, 116, 8, 88, 82, 117, 32, 134, 101, 19, 130, + 19, 18, 7, 116, 82, 52, 39, 23, 16, 102, 16, 55, 84, 104, 112, 16, 87, 52, 24, 16, 4, 0, 6, + 116, 54, 39, 102, 115, 0, 71, 93, 60, 42, 153, 35, 60, 198, 128, 216, 252, 113, 0, 89, 226, + 3, 24, 6, 96, 206, 237, 160, 181, 208, 159, 213, 222, 78, 39, 201, 222, 225, 222, 158, 89, + 190, 147, 163, 80, 172, 222, 115, 241, 255, 161, 135, 90, 41, 179, 151, 20, 9, 214, 38, 19, + 159, 114, 43, 100, 44, 41, 66, 249, 207, 101, 244, 168, 167, 205, 153, 13, 249, 159, 252, + 145, 188, 231, 2, 88, 13, 254, 84, 222, 33, 165, 213, 38, 14, 251, 240, 113, 88, 104, 32, + 204, 170, 136, 131, 94, 152, 39, 31, 53, 239, 33, 76, 235, 167, 180, 142, 79, 243, 230, + 216, 184, 100, 202, 5, 135, 32, 149, 82, 17, 233, 29, 220, 208, 192, 209, 59, 86, 143, 216, + 112, 239, 252, 77, 81, 246, 163, 61, 74, 242, 36, 242, 229, 6, 176, 234, 44, 67, 186, 99, + 120, 46, 101, 44, 102, 92, 232, 149, 81, 245, 1, 24, 45, 179, 128, 66, 231, 130, 143, 192, + 99, 179, 199, 83, 147, 97, 15, 119, 216, 13, 96, 119, 171, 40, 68, 51, 57, 174, 161, 211, + 191, 124, 173, 237, 128, 171, 136, 102, 205, 254, 19, 43, 247, 224, 46, 54, 91, 188, 130, + 194, 147, 192, 231, 91, 57, 148, 106, 191, 208, 214, 248, 223, 66, 7, 63, 254, 98, 86, 153, + 88, 164, 241, 252, 60, 42, 190, 188, 146, 207, 56, 142, 218, 202, 131, 139, 24, 249, 176, + 134, 123, 243, 138, 130, 40, 135, 134, 228, 141, 212, 82, 66, 101, 179, 77, 173, 0, 153, + 78, 250, 65, 102, 80, 178, 109, 42, 243, 35, 243, 210, 153, 2, 255, 28, 67, 209, 209, 5, + 246, 161, 21, 54, 172, 99, 182, 193, 196, 122, 119, 91, 1, 196, 213, 171, 195, 38, 102, + 118, 53, 51, 203, 155, 212, 219, 142, 61, 166, 247, 80, 85, 175, 110, 56, 233, 20, 162, + 186, 253, 151, 76, 215, 185, 196, 80, 23, 234, 123, 144, 54, 49, 139, 65, 56, 155, 63, 85, + 70, 105, 60, 98, 170, 92, 1, 1, 75, 180, 230, 22, 207, 202, 230, 178, 163, 195, 215, 16, + 34, 42, 163, 1, 193, 134, 122, 4, 195, 47, 189, 69, 202, 24, 107, 205, 236, 32, 234, 54, + 30, 241, 223, 131, 58, 159, 160, 30, 55, 113, 159, 207, 25, 71, 197, 122, 223, 167, 43, + 172, 46, 19, 117, 198, 121, 120, 157, 14, 133, 186, 156, 33, 254, 127, 91, 227, 60, 225, + 195, 124, 18, 154, 48, 161, 66, 145, 104, 223, 116, 215, 33, 249, 50, 212, 127, 146, 96, + 201, 149, 255, 137, 192, 210, 95, 244, 176, 46, 34, 165, 173, 232, 115, 68, 205, 139, 235, + 251, 115, 36, 36, 72, 92, 122, 201, 49, 244, 250, 32, 104, 222, 162, 94, 215, 117, 150, + 181, 227, 144, 75, 248, 202, 106, 222, 173, 250, 218, 127, 232, 123, 13, 190, 241, 49, 57, + 23, 145, 36, 187, 55, 140, 240, 223, 154, 99, 82, 29, 54, 164, 147, 173, 255, 145, 231, + 111, 87, 13, 135, 164, 112, 201, 91, 105, 91, 155, 51, 228, 30, 109, 115, 34, 52, 191, 63, + 19, 243, 175, 232, 233, 46, 250, 99, 124, 185, 193, 17, 79, 25, 87, 1, 250, 232, 151, 75, + 15, 115, 135, 129, 197, 121, 84, 170, 108, 230, 16, 166, 200, 102, 88, 44, 237, 48, 19, 73, + 166, 32, 45, 252, 170, 16, 254, 113, 219, 149, 169, 112, 226, 16, 12, 69, 188, 61, 121, + 135, 152, 90, 228, 253, 91, 164, 224, 144, 62, 19, 206, 58, 230, 138, 233, 109, 84, 0, 214, + 196, 121, 113, 183, 122, 157, 131, 111, 81, 215, 240, 61, 58, 12, 219, 235, 17, 1, 9, 43, + 11, 77, 66, 106, 218, 137, 9, 42, 129, 60, 3, 46, 12, 165, 138, 92, 213, 110, 142, 201, 88, + 94, 163, 161, 122, 251, 156, 148, 195, 138, 157, 195, 254, 131, 12, 41, 19, 68, 124, 49, + 51, 42, 186, 48, 159, 148, 21, 94, 174, 168, 10, 164, 75, 88, 29, 167, 145, 173, 9, 236, 4, + 239, 25, 69, 211, 64, 216, 145, 181, 144, 52, 134, 225, 125, 167, 62, 32, 115, 88, 206, + 127, 167, 80, 114, 223, 64, 55, 237, 143, 250, 26, 231, 94, 71, 74, 52, 29, 144, 179, 37, + 225, 233, 150, 255, 255, 67, 124, 254, 222, 15, 196, 160, 29, 254, 18, 213, 162, 109, 110, + 75, 97, 27, 229, 230, 104, 247, 14, 185, 172, 56, 124, 224, 200, 189, 192, 131, 83, 76, + 181, 235, 225, 217, 227, 206, 24, 179, 254, 2, 231, 181, 66, 233, 151, 238, 26, 24, 201, + 82, 85, 170, 37, 250, 163, 212, 109, 71, 143, 252, 37, 210, 227, 7, 205, 220, 11, 196, 170, + 113, 254, 86, 220, 249, 173, 142, 189, 1, 130, 97, 62, 187, 81, 11, 101, 217, 253, 29, 15, + 135, 150, 100, 106, 74, 71, 249, 171, 244, 64, 38, 169, 250, 49, 199, 90, 42, 172, 131, 83, + 110, 185, 223, 65, 16, 241, 62, 13, 253, 9, 109, 62, 176, 151, 249, 57, 129, 62, 158, 99, + 203, 193, 212, 91, 72, 229, 125, 83, 135, 121, 239, 99, 56, 55, 252, 14, 202, 9, 0, 202, + 239, 232, 192, 234, 106, 97, 45, 163, 52, 216, 71, 183, 75, 75, 252, 59, 211, 113, 205, 54, + 237, 254, 131, 193, 237, 109, 227, 238, 151, 26, 169, 247, 244, 253, 172, 216, 42, 150, + 143, 234, 227, 77, 102, 164, 27, 0, 121, 138, 228, 28, 72, 74, 214, 54, 56, 209, 197, 252, + 177, 239, 218, 153, 116, 84, 100, 239, 225, 189, 109, 67, 110, 195, 97, 88, 151, 110, 1, + 120, 174, 13, 245, 171, 25, 184, 38, 187, 253, 53, 142, 156, 101, 242, 190, 60, 223, 180, + 173, 75, 104, 96, 11, 49, 216, 233, 69, 33, 212, 125, 16, 141, 53, 9, 109, 93, 126, 39, 36, + 63, 90, 216, 77, 244, 171, 4, 133, 252, 213, 164, 182, 229, 134, 6, 36, 30, 231, 64, 32, + 127, 159, 215, 183, 81, 120, 184, 197, 10, 48, 61, 46, 173, 53, 145, 70, 148, 15, 199, 251, + 201, 211, 201, 231, 186, 42, 56, 136, 41, 191, 154, 80, 166, 255, 9, 29, 14, 195, 124, 117, + 151, 66, 181, 126, 80, 196, 15, 126, 87, 44, 200, 242, 206, 16, 196, 13, 64, 150, 116, 7, + 161, 195, 105, 41, 122, 10, 40, 243, 130, 241, 53, 178, 16, 217, 85, 190, 118, 144, 233, + 59, 107, 78, 242, 106, 236, 189, 182, 150, 3, 108, 182, 125, 47, 168, 145, 40, 83, 85, 169, + 40, 157, 251, 177, 186, 218, 78, 205, 9, 49, 88, 222, 153, 65, 102, 72, 50, 159, 181, 80, + 122, 48, 19, 223, 239, 80, 236, 204, 85, 16, 207, 5, 112, 98, 254, 71, 184, 56, 5, 42, 149, + 182, 154, 154, 136, 190, 35, 7, 126, 191, 42, 206, 140, 223, 140, 168, 100, 113, 205, 219, + 76, 104, 84, 246, 240, 6, 220, 238, 247, 43, 203, 142, 36, 98, 96, 89, 55, 168, 94, 48, + 239, 242, 228, 248, 170, 138, 52, 186, 25, 90, 38, 55, 150, 98, 117, 53, 32, 108, 26, 85, + 62, 62, 50, 241, 205, 96, 140, 150, 215, 189, 55, 127, 64, 222, 138, 131, 38, 7, 4, 3, 48, + 51, 10, 50, 111, 121, 32, 120, 228, 143, 112, 236, 159, 74, 102, 225, 89, 130, 60, 250, + 221, 73, 22, 151, 87, 87, 185, 64, 95, 127, 171, 8, 27, 246, 166, 65, 59, 16, 86, 94, 240, + 133, 24, 55, 156, 140, 216, 153, 54, 95, 228, 77, 18, 82, 184, 214, 240, 41, 223, 71, 228, + 208, 137, 96, 229, 43, 132, 151, 108, 44, 158, 168, 142, 65, 66, 44, 69, 62, 111, 206, 34, + 5, 59, 116, 56, 37, 236, 46, 77, 181, 235, 247, 44, 31, 232, 134, 134, 148, 205, 210, 3, + 124, 177, 171, 195, 147, 89, 210, 212, 0, 183, 25, 218, 103, 73, 223, 111, 130, 82, 186, + 149, 157, 201, 199, 113, 220, 85, 177, 49, 242, 109, 105, 129, 186, 148, 47, 71, 182, 147, + 25, 112, 55, 225, 37, 206, 172, 218, 237, 169, 174, 1, 2, 203, 63, 213, 231, 192, 20, 193, + 181, 55, 1, 248, 120, 55, 138, 166, 44, 49, 7, 184, 238, 215, 75, 167, 90, 247, 55, 153, + 43, 144, 210, 246, 44, 234, 168, 199, 108, 224, 196, 181, 65, 26, 192, 218, 20, 12, 48, 14, + 97, 40, 26, 212, 45, 205, 235, 1, 130, 158, 119, 87, 1, 2, 131, 11, 15, 43, 202, 131, 9, + 14, 112, 230, 229, 252, 238, 125, 48, 105, 81, 109, 64, 240, 232, 6, 56, 255, 142, 121, 5, + 114, 90, 143, 120, 229, 110, 152, 220, 166, 123, 39, 133, 78, 215, 40, 184, 156, 3, 43, 72, + 22, 66, 73, 73, 240, 200, 79, 29, 46, 184, 44, 121, 80, 126, 143, 153, 60, 64, 21, 31, 155, + 137, 110, 95, 207, 238, 64, 204, 204, 34, 76, 253, 176, 138, 218, 67, 28, 223, 241, 178, + 84, 195, 102, 175, 105, 244, 94, 60, 220, 126, 112, 252, 220, 218, 235, 235, 76, 19, 60, + 78, 245, 157, 142, 16, 165, 241, 194, 198, 89, 80, 191, 226, 117, 86, 32, 246, 202, 229, + 52, 184, 181, 181, 133, 149, 148, 91, 197, 39, 52, 217, 72, 119, 191, 148, 174, 58, 136, + 65, 252, 74, 123, 36, 122, 212, 118, 3, 102, 172, 31, 206, 221, 152, 148, 201, 115, 52, 78, + 92, 20, 212, 50, 246, 209, 148, 39, 75, 194, 200, 2, 99, 22, 134, 2, 106, 249, 77, 30, 79, + 237, 129, 70, 81, 212, 16, 28, 211, 187, 62, 24, 214, 108, 36, 98, 26, 117, 215, 120, 210, + 15, 71, 90, 126, 85, 12, 146, 203, 151, 87, 43, 200, 138, 14, 101, 232, 90, 77, 210, 225, + 6, 61, 244, 76, 91, 94, 19, 201, 116, 248, 95, 219, 166, 234, 100, 125, 233, 158, 11, 118, + 204, 0, 223, 69, 105, 126, 169, 249, 124, 148, 29, 152, 98, 150, 30, 99, 164, 211, 51, 175, + 238, 113, 68, 250, 76, 147, 251, 167, 213, 84, 231, 222, 192, 53, 186, 186, 129, 144, 103, + 228, 61, 23, 1, 64, 92, 240, 94, 97, 217, 198, 34, 211, 1, 48, 235, 85, 200, 234, 27, 112, + 227, 111, 120, 182, 37, 202, 39, 169, 199, 213, 255, 15, 139, 4, 229, 65, 188, 42, 247, + 182, 92, 153, 187, 82, 12, 71, 76, 121, 98, 187, 53, 140, 27, 144, 103, 234, 199, 196, 235, + 120, 82, 77, 191, 60, 195, 132, 243, 212, 70, 123, 105, 106, 37, 160, 234, 48, 209, 71, 97, + 42, 198, 150, 134, 201, 40, 112, 112, 72, 164, 237, 103, 149, 47, 123, 122, 129, 77, 55, + 116, 94, 64, 0, 38, 4, 250, 133, 134, 113, 109, 126, 101, 54, 123, 188, 158, 120, 146, 156, + 133, 140, 232, 229, 106, 36, 207, 201, 164, 243, 119, 251, 50, 124, 11, 239, 181, 219, 165, + 196, 25, 121, 240, 64, 157, 20, 205, 167, 251, 27, 49, 92, 244, 193, 3, 60, 190, 50, 175, + 182, 107, 15, 40, 117, 154, 70, 183, 120, 246, 55, 98, 251, 83, 110, 150, 148, 240, 51, + 221, 121, 165, 135, 149, 247, 211, 174, 125, 187, 20, 61, 238, 42, 45, 56, 118, 79, 216, + 174, 23, 150, 33, 101, 46, 7, 97, 152, 82, 143, 10, 230, 0, 115, 11, 220, 106, 61, 161, 80, + 30, 239, 62, 211, 130, 218, 2, 214, 177, 226, 0, 74, 124, 79, 226, 223, 173, 230, 112, 28, + 81, 240, 201, 112, 2, 174, 115, 70, 228, 102, 49, 114, 120, 150, 204, 52, 211, 90, 250, + 128, 48, 116, 238, 72, 215, 63, 185, 114, 71, 5, 93, 184, 181, 108, 47, 142, 6, 139, 63, + 114, 31, 161, 251, 210, 243, 19, 112, 198, 18, 62, 250, 222, 91, 222, 126, 67, 155, 68, + 135, 165, 154, 175, 121, 128, 85, 140, 106, 199, 147, 183, 164, 3, 93, 53, 181, 66, 22, + 125, 198, 251, 31, 70, 240, 17, 180, 104, 242, 17, 5, 70, 126, 121, 154, 12, 215, 198, 89, + 69, 22, 177, 104, 1, 53, 168, 129, 91, 147, 125, 9, 121, 236, 27, 102, 247, 89, 163, 135, + 2, 44, 102, 184, 136, 210, 151, 190, 3, 80, 87, 146, 182, 151, 69, 151, 183, 253, 104, 235, + 255, 10, 167, 81, 50, 187, 99, 135, 30, 250, 50, 183, 182, 92, 185, 31, 184, 75, 191, 170, + 110, 21, 29, 190, 200, 36, 181, 125, 61, 217, 41, 36, 147, 76, 40, 127, 84, 9, 132, 88, 3, + 219, 88, 129, 75, 238, 178, 190, 48, 233, 200, 228, 205, 85, 146, 59, 186, 96, 31, 75, 76, + 235, 126, 161, 36, 65, 52, 106, 118, 218, 168, 231, 72, 37, 43, 166, 40, 79, 130, 229, 214, + 100, 189, 174, 106, 227, 235, 14, 18, 130, 115, 15, 14, 182, 220, 97, 54, 155, 15, 188, + 230, 98, 243, 3, 198, 251, 148, 118, 74, 59, 127, 151, 135, 130, 215, 45, 107, 247, 36, 7, + 87, 174, 123, 198, 113, 206, 43, 84, 162, 97, 236, 92, 12, 162, 137, 199, 84, 46, 211, 76, + 236, 190, 246, 186, 194, 212, 210, 174, 168, 227, 187, 196, 49, 178, 130, 226, 170, 226, + 197, 87, 193, 65, 239, 212, 89, 226, 21, 248, 206, 34, 210, 182, 216, 59, 189, 86, 236, 97, + 225, 139, 93, 55, 44, 135, 152, 251, 48, 1, 80, 236, 109, 60, 34, 10, 143, 188, 183, 232, + 229, 105, 123, 212, 172, 112, 147, 120, 191, 135, 82, 107, 75, 253, 124, 184, 107, 43, 205, + 96, 220, 112, 232, 128, 0, 43, 14, 82, 74, 254, 64, 151, 53, 171, 228, 224, 254, 41, 104, + 138, 36, 139, 243, 197, 93, 115, 92, 171, 178, 103, 3, 161, 31, 100, 246, 1, 3, 223, 81, + 179, 152, 214, 154, 223, 71, 239, 219, 214, 174, 159, 19, 248, 239, 47, 96, 219, 207, 84, + 186, 254, 217, 99, 242, 78, 172, 179, 140, 143, 84, 204, 168, 58, 67, 196, 227, 116, 210, + 253, 26, 59, 138, 253, 198, 117, 69, 170, 104, 57, 26, 92, 154, 193, 9, 7, 70, 209, 114, + 173, 191, 169, 112, 65, 129, 59, 234, 229, 41, 254, 131, 61, 249, 42, 29, 1, 70, 171, 171, + 233, 155, 230, 49, 228, 83, 112, 73, 106, 174, 45, 231, 190, 182, 238, 86, 232, 172, 103, + 15, 46, 216, 85, 183, 37, 91, 179, 181, 87, 178, 117, 248, 47, 253, 224, 71, 163, + ]; + let expected_pk_bytes = [ + 23, 178, 175, 197, 3, 146, 2, 23, 99, 85, 17, 220, 25, 223, 158, 77, 54, 27, 114, 162, 130, + 181, 61, 104, 173, 208, 32, 252, 216, 46, 47, 228, 169, 64, 110, 96, 111, 48, 254, 72, 158, + 202, 45, 166, 165, 31, 186, 69, 75, 129, 1, 248, 239, 189, 207, 3, 16, 222, 186, 35, 233, + 22, 237, 73, 199, 214, 115, 144, 16, 174, 251, 252, 23, 5, 14, 153, 209, 232, 136, 11, 229, + 214, 241, 247, 113, 140, 235, 123, 237, 62, 124, 83, 11, 225, 77, 20, 31, 134, 36, 78, 219, + 90, 114, 90, 240, 208, 70, 71, 202, 61, 10, 116, 186, 48, 231, 63, 215, 229, 14, 123, 218, + 10, 31, 213, 150, 77, 58, 33, 242, 104, 116, 23, 194, 167, 206, 167, 198, 129, 78, 113, + 218, 38, 238, 57, 109, 83, 166, 108, 36, 160, 210, 89, 205, 46, 114, 139, 43, 194, 61, 98, + 89, 88, 218, 137, 192, 213, 10, 34, 10, 56, 90, 215, 249, 211, 44, 131, 88, 26, 78, 58, + 123, 179, 141, 180, 101, 61, 50, 137, 12, 107, 105, 128, 75, 242, 211, 100, 51, 135, 227, + 22, 90, 2, 35, 129, 159, 135, 92, 250, 252, 160, 195, 20, 209, 152, 223, 137, 92, 13, 3, 7, + 56, 25, 23, 168, 104, 168, 130, 28, 174, 235, 62, 111, 12, 162, 112, 215, 214, 112, 223, + 130, 8, 6, 120, 218, 96, 36, 242, 2, 46, 1, 94, 11, 116, 140, 227, 223, 152, 180, 57, 169, + 75, 241, 134, 79, 39, 103, 243, 209, 122, 125, 75, 207, 91, 164, 207, 233, 95, 181, 15, 74, + 58, 56, 53, 127, 135, 145, 155, 231, 196, 137, 54, 132, 237, 53, 197, 107, 132, 85, 45, + 125, 154, 230, 187, 64, 73, 113, 174, 66, 26, 242, 232, 252, 55, 36, 9, 14, 104, 223, 176, + 146, 69, 30, 46, 203, 0, 110, 181, 109, 103, 171, 250, 130, 166, 25, 218, 12, 228, 12, 19, + 242, 223, 115, 145, 154, 237, 59, 226, 50, 12, 151, 234, 47, 218, 96, 42, 40, 185, 29, 73, + 206, 183, 83, 56, 104, 170, 19, 75, 209, 56, 168, 94, 42, 6, 228, 106, 43, 146, 238, 236, + 203, 123, 31, 45, 120, 73, 208, 14, 245, 3, 97, 208, 40, 191, 250, 123, 227, 84, 62, 73, + 165, 172, 145, 221, 104, 56, 211, 172, 123, 56, 110, 160, 183, 168, 59, 6, 42, 173, 155, + 82, 148, 97, 234, 48, 141, 122, 32, 241, 153, 253, 190, 72, 175, 73, 202, 92, 30, 247, 108, + 195, 165, 202, 211, 56, 50, 161, 169, 121, 65, 248, 79, 194, 84, 8, 236, 236, 188, 219, 98, + 55, 37, 74, 228, 142, 110, 51, 23, 80, 40, 24, 13, 176, 152, 104, 227, 37, 224, 40, 200, + 43, 220, 62, 248, 167, 176, 119, 189, 206, 32, 224, 217, 227, 12, 219, 8, 149, 52, 141, + 144, 125, 26, 188, 52, 123, 68, 104, 215, 123, 147, 162, 66, 143, 3, 45, 97, 30, 90, 155, + 242, 64, 16, 252, 82, 46, 57, 49, 139, 243, 5, 107, 185, 219, 119, 208, 29, 125, 150, 200, + 47, 132, 69, 121, 52, 251, 109, 208, 62, 244, 36, 87, 52, 66, 243, 24, 180, 167, 64, 75, + 156, 140, 193, 100, 182, 221, 226, 92, 138, 112, 100, 206, 109, 185, 141, 36, 241, 52, 107, + 171, 29, 250, 224, 105, 173, 30, 243, 214, 176, 70, 221, 22, 120, 208, 220, 203, 233, 50, + 194, 109, 75, 72, 108, 125, 208, 139, 70, 145, 48, 87, 132, 126, 130, 18, 178, 218, 196, + 143, 118, 47, 2, 112, 40, 247, 230, 67, 110, 171, 5, 231, 158, 9, 148, 142, 93, 128, 79, + 37, 182, 176, 73, 61, 26, 242, 190, 253, 6, 93, 230, 21, 55, 249, 238, 47, 223, 152, 237, + 80, 30, 17, 255, 131, 173, 34, 33, 108, 52, 91, 134, 127, 164, 187, 214, 200, 214, 242, 19, + 152, 6, 126, 157, 160, 208, 125, 11, 222, 121, 49, 236, 139, 170, 18, 128, 197, 249, 202, + 255, 179, 143, 128, 184, 10, 246, 237, 235, 40, 150, 171, 255, 155, 130, 118, 33, 105, 0, + 45, 6, 1, 108, 190, 194, 123, 213, 41, 168, 175, 59, 240, 253, 49, 115, 95, 72, 218, 0, + 126, 63, 121, 168, 80, 32, 53, 86, 123, 201, 248, 119, 19, 32, 228, 56, 9, 28, 72, 166, 68, + 164, 131, 168, 187, 98, 1, 205, 243, 237, 43, 64, 44, 113, 31, 44, 81, 243, 150, 103, 163, + 137, 29, 120, 208, 131, 38, 140, 59, 254, 2, 174, 36, 80, 164, 211, 127, 187, 10, 183, 88, + 201, 122, 245, 255, 42, 77, 78, 67, 249, 44, 209, 75, 62, 159, 10, 163, 221, 176, 131, 215, + 143, 255, 255, 115, 14, 142, 162, 204, 168, 116, 104, 174, 148, 34, 119, 107, 229, 44, 152, + 160, 35, 237, 28, 127, 241, 141, 225, 227, 175, 180, 48, 171, 84, 8, 8, 173, 39, 180, 218, + 101, 86, 218, 214, 52, 180, 202, 191, 152, 64, 218, 37, 36, 56, 133, 224, 93, 127, 76, 210, + 94, 184, 193, 230, 136, 75, 135, 116, 44, 157, 33, 58, 183, 53, 17, 248, 193, 169, 41, 71, + 164, 109, 192, 110, 211, 188, 79, 72, 84, 172, 112, 159, 70, 53, 128, 140, 21, 234, 206, + 94, 78, 60, 62, 167, 254, 131, 93, 187, 213, 155, 251, 27, 46, 161, 207, 35, 184, 26, 87, + 58, 189, 165, 191, 212, 0, 240, 10, 34, 21, 163, 17, 159, 202, 45, 218, 176, 91, 44, 194, + 239, 33, 85, 162, 117, 147, 70, 154, 50, 194, 33, 148, 147, 185, 174, 53, 249, 20, 117, + 118, 36, 39, 246, 69, 5, 5, 102, 82, 139, 105, 208, 170, 229, 146, 133, 85, 216, 86, 157, + 49, 214, 6, 209, 133, 214, 154, 76, 14, 169, 54, 117, 214, 58, 242, 162, 198, 204, 100, 66, + 183, 225, 38, 87, 7, 101, 131, 27, 139, 34, 103, 86, 20, 210, 211, 58, 229, 209, 136, 178, + 248, 116, 143, 250, 46, 31, 208, 146, 80, 224, 195, 246, 176, 103, 178, 68, 68, 13, 42, + 252, 54, 103, 28, 189, 111, 255, 243, 126, 11, 118, 34, 121, 184, 12, 18, 51, 131, 105, 16, + 126, 208, 210, 213, 189, 201, 125, 54, 21, 62, 115, 41, 40, 138, 74, 44, 238, 42, 163, 23, + 40, 133, 122, 64, 174, 46, 211, 169, 242, 135, 158, 58, 65, 252, 166, 228, 138, 61, 253, + 10, 135, 34, 138, 135, 174, 31, 19, 65, 69, 160, 97, 159, 159, 221, 179, 155, 225, 208, 82, + 223, 75, 90, 107, 227, 177, 71, 130, 224, 40, 52, 90, 111, 107, 153, 218, 223, 57, 186, 23, + 134, 207, 32, 114, 98, 35, 23, 28, 57, 249, 145, 108, 8, 154, 214, 55, 218, 91, 163, 154, + 63, 34, 101, 46, 64, 40, 43, 231, 12, 97, 128, 68, 134, 45, 170, 87, 30, 85, 249, 21, 43, + 82, 45, 93, 105, 79, 80, 103, 249, 228, 90, 190, 209, 133, 96, 94, 241, 68, 40, 218, 13, + 198, 140, 27, 121, 31, 67, 73, 213, 92, 224, 79, 19, 10, 142, 251, 16, 120, 47, 190, 216, + 243, 224, 208, 177, 36, 88, 73, 100, 170, 1, 106, 60, 192, 108, 71, 206, 175, 244, 124, + 164, 116, 14, 174, 106, 63, 76, 34, 84, 35, 153, 51, 254, 95, 140, 30, 252, 2, 81, 122, + 134, 69, 255, 255, 205, 88, 137, 43, 16, 68, 227, 179, 106, 80, 202, 224, 29, 24, 26, 124, + 78, 229, 194, 125, 187, 50, 159, 11, 80, 245, 44, 157, 25, 73, 111, 155, 188, 149, 120, + 190, 13, 181, 35, 102, 144, 115, 185, 42, 213, 73, 123, 214, 36, 127, 187, 168, 176, 177, + 12, 231, 125, 4, 99, 221, 188, 254, 58, 63, 131, 136, 25, 223, 243, 18, 238, 8, 80, 12, + 158, 238, 159, 228, 231, 65, 40, 39, 182, 186, 241, 1, 106, 44, 202, 141, 43, 238, 168, 20, + 87, 45, 72, 9, 67, 119, 129, 175, 56, 235, 75, 219, 179, 28, 154, 36, 93, 13, 76, 112, 183, + 4, 41, 213, 155, 20, 199, 231, 30, 107, 227, 5, 193, 99, 107, 124, 7, 155, 13, 152, 184, + 150, 246, 127, 9, 38, 235, 146, 150, 239, 210, 56, 228, 194, 31, 166, 175, 40, 229, 19, + 118, 38, 231, 71, 233, 167, 91, 226, 44, 2, 195, 131, 160, 48, 115, 120, 80, 253, 49, 19, + 223, 217, 223, 20, 116, 102, 52, 26, 57, 124, 153, 196, 252, 52, 187, 222, 38, 159, 251, + 144, 152, 220, 153, 204, 188, 62, 12, 203, 119, 136, 46, 34, 102, 124, 112, 91, 197, 191, + 35, 213, 35, 235, 235, 162, 27, 23, 99, 103, 69, 67, 7, 10, 38, 179, 132, 218, 212, 11, + 243, 45, 12, 208, 82, 95, 193, 188, 133, 6, 100, 186, 6, 43, 51, 189, 191, 230, 47, 64, 7, + 19, 135, 194, 155, 117, 99, 175, 158, 154, 159, 188, 15, 160, 203, 53, 15, 249, 182, 216, + 74, 86, 9, 158, 55, 50, 199, 7, 123, 9, 57, 69, 90, 116, 234, 208, 10, 189, 122, 187, 139, + 111, 186, 221, 144, 60, 44, 42, 76, 140, 37, 15, 29, 175, 19, 242, 125, 215, 10, 215, 100, + 161, 153, 221, 198, 192, 28, 121, 33, 146, 169, 103, 121, 170, 191, 176, 61, 252, 247, 201, + 16, 142, 236, 154, 102, 186, 169, 23, 117, 36, 174, 36, 177, 154, 234, 55, 23, 176, 70, + 214, 91, 177, 184, 208, 247, 223, 7, 155, 166, 50, 205, 2, 72, 108, 249, 24, 105, 137, 29, + 158, 95, 200, 126, 166, 123, 131, 178, 188, 158, 184, 169, 227, 239, 46, 253, 137, 133, + 113, 223, 60, 232, 89, 63, 232, 148, 160, 227, 227, 210, 6, 79, 3, 254, 123, 12, 30, 227, + 13, 189, 167, 77, 1, 103, 113, 72, 170, 174, 119, 242, 81, 220, 118, 32, 54, 38, 229, 122, + 185, 217, 108, 121, 118, 240, 19, 148, 120, 221, 3, 131, 50, 166, 118, 34, 124, 146, 72, + 211, 122, 54, 138, 55, 141, 151, 141, 137, 15, 91, 141, 46, 60, 93, 39, 22, 207, 216, 88, + 140, 157, 13, 168, 115, 113, 205, 218, 71, 203, 246, 188, 173, 153, 148, 223, 12, 239, 239, + 162, 206, 40, 144, 130, 95, 194, 43, 171, 237, 209, 90, 185, 52, 66, 234, 216, 224, 192, 8, + 230, 246, 125, 210, 233, 26, 15, 55, 219, 139, 246, 205, 150, 66, 195, 186, 29, 5, 122, + 201, 158, 65, 187, 180, 122, 192, 64, 170, 254, 111, 25, 121, 167, 252, 204, 45, 227, 5, + 150, 69, 214, 223, 211, 49, 75, 241, 172, 103, 2, 193, 138, 200, 254, 6, 27, 139, 202, 22, + 139, 167, 106, 222, 221, 130, 221, 213, 26, 87, 220, 75, 62, 229, 24, 134, 72, 54, 177, + 233, 118, 124, 161, 48, 165, 74, 225, 200, 2, 178, 129, 22, 27, 208, 216, 18, 122, 150, + 220, 137, 223, 221, 78, 168, 137, 7, 76, 142, 40, 226, 89, 147, 226, 224, 50, 161, 170, + 114, 234, 217, 84, 155, 29, 241, 221, 233, 198, 110, 68, 58, 154, 255, 187, 139, 222, 236, + 43, 142, 166, 120, 182, 120, 77, 55, 140, 93, 180, 115, 83, 196, 125, 7, 48, 107, 228, 154, + 163, 96, 156, 158, 49, 240, 33, 225, 58, 131, 61, 79, 215, 177, 254, 50, 47, 161, 122, + ]; + let expected_sig_bytes = [ + 143, 236, 234, 0, 48, 184, 171, 178, 167, 77, 111, 6, 27, 16, 9, 46, 38, 211, 216, 41, 93, + 162, 120, 70, 176, 4, 115, 29, 225, 183, 135, 220, 91, 41, 193, 238, 255, 40, 161, 90, 242, + 87, 196, 47, 218, 2, 126, 214, 26, 60, 103, 244, 122, 175, 91, 117, 45, 89, 77, 49, 126, + 174, 0, 90, 220, 207, 12, 101, 59, 181, 158, 218, 80, 115, 105, 110, 77, 243, 96, 200, 234, + 24, 175, 170, 42, 86, 73, 102, 45, 25, 132, 221, 149, 137, 6, 27, 138, 149, 48, 64, 211, + 175, 192, 53, 121, 137, 248, 186, 88, 35, 220, 71, 50, 228, 235, 161, 235, 162, 230, 163, + 129, 87, 108, 74, 173, 130, 46, 4, 2, 217, 205, 64, 223, 220, 14, 76, 168, 5, 54, 161, 89, + 105, 52, 128, 160, 89, 180, 153, 138, 42, 135, 190, 44, 98, 244, 197, 35, 27, 188, 21, 204, + 141, 58, 4, 215, 132, 63, 91, 243, 197, 224, 241, 19, 73, 116, 187, 72, 233, 123, 181, 212, + 44, 147, 51, 120, 141, 140, 200, 0, 191, 97, 36, 100, 204, 149, 52, 153, 7, 160, 66, 8, 33, + 207, 67, 112, 137, 166, 83, 93, 74, 21, 98, 76, 205, 1, 167, 99, 189, 20, 148, 140, 30, 85, + 161, 153, 149, 131, 141, 64, 202, 138, 38, 14, 201, 168, 3, 230, 87, 165, 38, 79, 214, 163, + 5, 126, 118, 109, 231, 149, 144, 87, 22, 222, 46, 255, 189, 177, 34, 124, 253, 61, 106, 96, + 38, 82, 4, 101, 95, 211, 246, 186, 11, 218, 70, 180, 127, 163, 125, 203, 31, 77, 114, 20, + 73, 90, 55, 115, 227, 213, 77, 105, 247, 243, 60, 32, 182, 96, 6, 154, 126, 187, 160, 200, + 55, 166, 127, 181, 177, 148, 250, 240, 242, 181, 208, 39, 54, 235, 185, 196, 24, 178, 27, + 248, 152, 228, 116, 220, 15, 208, 214, 209, 48, 230, 74, 238, 68, 85, 71, 249, 35, 147, 22, + 170, 6, 204, 52, 124, 9, 179, 117, 79, 207, 181, 15, 153, 198, 126, 83, 181, 244, 225, 123, + 33, 158, 148, 70, 35, 235, 137, 150, 32, 106, 78, 183, 239, 251, 158, 105, 214, 212, 229, + 27, 149, 187, 216, 72, 53, 48, 189, 213, 37, 68, 83, 108, 164, 39, 33, 8, 22, 211, 22, 238, + 253, 106, 130, 75, 202, 81, 221, 115, 134, 110, 206, 43, 229, 63, 94, 251, 233, 39, 134, + 59, 217, 187, 206, 115, 213, 94, 177, 244, 2, 253, 69, 61, 219, 63, 194, 219, 227, 218, + 228, 138, 100, 44, 140, 165, 186, 29, 5, 228, 61, 3, 62, 187, 243, 77, 248, 254, 76, 104, + 217, 172, 66, 187, 179, 151, 93, 1, 173, 71, 103, 10, 218, 211, 226, 193, 67, 160, 3, 163, + 184, 60, 8, 27, 124, 39, 195, 27, 246, 198, 194, 180, 186, 4, 80, 75, 184, 160, 25, 6, 148, + 106, 255, 212, 101, 214, 149, 192, 131, 86, 62, 27, 246, 107, 23, 163, 69, 96, 158, 74, 91, + 205, 52, 151, 185, 64, 242, 65, 102, 236, 249, 232, 76, 149, 54, 69, 95, 182, 41, 83, 199, + 7, 11, 60, 172, 88, 170, 98, 25, 31, 240, 41, 149, 167, 66, 255, 197, 65, 153, 180, 81, + 247, 226, 79, 93, 24, 188, 142, 218, 225, 77, 142, 227, 132, 198, 59, 86, 55, 234, 163, 28, + 100, 55, 201, 51, 219, 241, 184, 78, 8, 167, 140, 66, 240, 254, 46, 54, 59, 127, 4, 202, + 64, 31, 72, 223, 246, 169, 90, 206, 155, 71, 137, 42, 27, 68, 211, 137, 242, 208, 90, 26, + 130, 80, 112, 131, 156, 120, 87, 189, 136, 10, 45, 30, 90, 13, 90, 113, 164, 21, 135, 10, + 236, 113, 58, 66, 207, 217, 151, 7, 173, 63, 70, 0, 106, 36, 23, 184, 30, 8, 151, 93, 40, + 245, 146, 244, 46, 42, 77, 38, 139, 66, 236, 54, 106, 21, 62, 192, 92, 78, 225, 135, 198, + 171, 7, 160, 181, 249, 224, 154, 168, 187, 122, 24, 198, 119, 91, 74, 165, 56, 218, 171, + 151, 104, 183, 146, 253, 34, 61, 206, 82, 172, 186, 14, 141, 104, 202, 126, 235, 68, 145, + 195, 68, 18, 149, 129, 218, 6, 28, 97, 64, 17, 37, 173, 65, 149, 101, 0, 21, 15, 147, 119, + 234, 194, 134, 90, 196, 5, 230, 113, 176, 165, 1, 202, 160, 123, 180, 56, 59, 96, 7, 59, + 100, 253, 123, 2, 116, 183, 185, 9, 84, 3, 30, 186, 102, 43, 157, 155, 23, 45, 115, 182, + 199, 249, 234, 249, 213, 134, 123, 93, 151, 190, 156, 186, 31, 29, 92, 7, 161, 231, 29, + 183, 135, 147, 174, 184, 79, 164, 1, 149, 55, 140, 229, 169, 123, 107, 102, 138, 109, 57, + 107, 247, 73, 214, 168, 200, 241, 243, 186, 133, 159, 240, 69, 145, 66, 103, 74, 200, 184, + 178, 105, 16, 214, 138, 98, 82, 196, 162, 202, 50, 54, 49, 73, 23, 238, 209, 223, 9, 114, + 220, 59, 12, 45, 18, 231, 59, 48, 74, 210, 109, 68, 36, 182, 116, 84, 162, 182, 154, 60, + 185, 250, 198, 125, 69, 181, 45, 215, 104, 60, 11, 74, 209, 223, 165, 93, 10, 208, 227, 5, + 80, 117, 251, 31, 235, 152, 142, 148, 198, 25, 239, 229, 18, 106, 17, 84, 164, 34, 117, 17, + 88, 139, 234, 19, 139, 237, 207, 245, 211, 78, 247, 144, 181, 231, 185, 174, 137, 85, 241, + 82, 187, 29, 206, 114, 62, 126, 191, 97, 56, 7, 110, 243, 12, 86, 183, 238, 207, 158, 225, + 129, 118, 196, 157, 148, 29, 75, 230, 239, 49, 41, 35, 1, 181, 223, 206, 228, 195, 135, + 254, 193, 70, 232, 232, 71, 203, 79, 209, 104, 69, 86, 96, 185, 245, 174, 170, 32, 126, 73, + 245, 50, 124, 232, 172, 192, 24, 72, 109, 31, 83, 104, 6, 73, 31, 116, 159, 181, 94, 144, + 146, 185, 255, 177, 194, 184, 68, 110, 248, 216, 176, 164, 56, 62, 155, 161, 11, 32, 248, + 51, 152, 19, 162, 35, 224, 151, 171, 6, 39, 179, 48, 136, 178, 186, 59, 127, 140, 10, 89, + 243, 97, 248, 14, 215, 70, 16, 174, 244, 132, 0, 203, 111, 104, 145, 155, 100, 121, 236, + 250, 29, 210, 243, 143, 127, 46, 101, 84, 214, 33, 137, 51, 35, 22, 255, 184, 155, 240, + 159, 0, 2, 178, 167, 54, 119, 161, 172, 215, 106, 126, 111, 242, 3, 31, 151, 255, 134, 119, + 17, 52, 23, 227, 198, 5, 91, 212, 17, 251, 83, 32, 2, 249, 150, 102, 81, 169, 127, 131, + 246, 175, 135, 145, 15, 195, 88, 219, 20, 51, 252, 127, 163, 210, 187, 90, 96, 65, 69, 15, + 207, 94, 100, 46, 64, 197, 170, 255, 20, 229, 252, 210, 198, 5, 139, 200, 149, 96, 118, + 185, 111, 200, 38, 0, 153, 142, 54, 24, 101, 38, 134, 120, 179, 66, 178, 160, 19, 166, 166, + 100, 241, 60, 11, 231, 48, 39, 188, 166, 200, 174, 42, 52, 74, 110, 165, 58, 255, 148, 44, + 173, 201, 231, 159, 44, 29, 17, 202, 187, 114, 63, 81, 123, 243, 156, 120, 102, 178, 118, + 226, 203, 161, 194, 70, 39, 225, 148, 134, 192, 61, 95, 110, 19, 78, 134, 85, 213, 225, + 253, 49, 47, 199, 173, 61, 33, 96, 126, 201, 11, 207, 197, 72, 3, 170, 80, 139, 124, 124, + 237, 106, 88, 32, 50, 207, 14, 220, 235, 52, 15, 241, 121, 110, 66, 10, 176, 68, 215, 200, + 69, 43, 185, 197, 165, 232, 171, 139, 116, 163, 75, 13, 211, 173, 56, 159, 132, 72, 14, + 188, 90, 200, 247, 98, 55, 254, 31, 96, 5, 107, 127, 131, 203, 5, 179, 172, 238, 236, 226, + 95, 13, 2, 75, 160, 45, 204, 38, 226, 10, 35, 53, 135, 10, 14, 233, 19, 221, 168, 18, 100, + 204, 41, 178, 215, 0, 113, 65, 248, 0, 251, 156, 239, 124, 31, 89, 254, 149, 97, 103, 58, + 246, 66, 161, 109, 234, 172, 205, 115, 8, 83, 13, 131, 144, 124, 76, 190, 191, 214, 76, + 252, 32, 55, 164, 130, 85, 104, 141, 168, 31, 179, 253, 151, 243, 189, 210, 108, 171, 67, + 114, 217, 66, 206, 212, 239, 119, 242, 88, 162, 227, 69, 234, 19, 243, 93, 172, 93, 133, + 185, 6, 245, 126, 144, 141, 199, 194, 57, 105, 193, 83, 60, 214, 191, 156, 133, 163, 194, + 109, 17, 88, 51, 59, 105, 234, 125, 77, 76, 193, 74, 148, 29, 140, 129, 94, 84, 253, 172, + 88, 26, 162, 150, 46, 16, 123, 189, 74, 89, 107, 20, 224, 203, 236, 167, 81, 199, 164, 14, + 171, 7, 12, 229, 20, 231, 221, 50, 71, 101, 9, 85, 79, 44, 194, 84, 198, 72, 58, 244, 46, + 238, 9, 78, 6, 130, 27, 54, 128, 49, 130, 249, 234, 126, 45, 86, 62, 193, 120, 156, 244, + 94, 78, 98, 200, 38, 204, 232, 156, 183, 16, 70, 72, 63, 41, 218, 77, 71, 163, 86, 225, + 172, 178, 184, 143, 240, 0, 207, 49, 122, 124, 216, 95, 59, 74, 62, 245, 39, 30, 43, 45, + 133, 49, 176, 230, 85, 9, 55, 153, 41, 65, 168, 223, 249, 238, 0, 218, 225, 235, 75, 245, + 169, 58, 26, 132, 87, 212, 95, 225, 104, 45, 74, 120, 183, 227, 166, 174, 37, 107, 150, 68, + 62, 80, 94, 47, 180, 87, 217, 163, 167, 62, 107, 78, 203, 121, 134, 125, 211, 199, 135, 11, + 12, 254, 166, 24, 195, 172, 55, 61, 165, 4, 135, 251, 217, 23, 70, 214, 116, 156, 39, 57, + 8, 117, 202, 152, 33, 93, 191, 72, 238, 61, 42, 76, 189, 168, 213, 112, 152, 155, 149, 22, + 140, 71, 31, 255, 249, 65, 1, 51, 192, 161, 147, 234, 106, 17, 234, 135, 225, 134, 2, 93, + 240, 230, 162, 130, 204, 208, 69, 162, 148, 123, 78, 163, 169, 117, 167, 216, 174, 42, 57, + 233, 224, 107, 103, 163, 61, 66, 120, 38, 21, 182, 148, 194, 101, 127, 173, 174, 202, 225, + 146, 30, 62, 218, 52, 13, 248, 1, 21, 196, 183, 92, 122, 36, 202, 76, 86, 16, 225, 245, + 104, 83, 177, 240, 182, 159, 134, 90, 141, 212, 139, 50, 220, 120, 176, 175, 157, 97, 35, + 168, 86, 231, 61, 90, 195, 228, 99, 170, 203, 198, 90, 238, 5, 80, 240, 59, 84, 142, 134, + 62, 57, 143, 165, 49, 167, 63, 178, 148, 185, 193, 212, 140, 50, 19, 172, 123, 130, 16, + 141, 65, 107, 89, 127, 250, 188, 247, 207, 244, 93, 190, 123, 204, 227, 92, 213, 111, 201, + 148, 137, 54, 120, 53, 232, 18, 122, 120, 192, 157, 137, 1, 249, 50, 60, 228, 238, 49, 5, + 152, 252, 233, 90, 11, 15, 34, 9, 251, 13, 139, 115, 136, 21, 236, 237, 206, 88, 151, 220, + 167, 60, 213, 237, 238, 127, 42, 45, 31, 22, 126, 58, 105, 104, 63, 254, 117, 39, 207, 35, + 243, 6, 205, 46, 212, 173, 122, 89, 142, 249, 175, 159, 139, 163, 155, 226, 47, 246, 76, + 152, 72, 251, 167, 7, 51, 254, 156, 25, 158, 74, 47, 195, 173, 231, 127, 192, 73, 8, 191, + 229, 30, 16, 142, 172, 98, 110, 145, 67, 61, 249, 252, 209, 160, 86, 157, 36, 160, 173, + 121, 56, 97, 84, 55, 5, 142, 31, 81, 186, 39, 227, 151, 53, 225, 202, 140, 143, 230, 3, 60, + 162, 66, 92, 113, 209, 105, 122, 187, 205, 35, 130, 35, 67, 40, 123, 9, 124, 131, 79, 103, + 199, 250, 251, 153, 162, 51, 158, 249, 8, 51, 57, 54, 19, 221, 171, 155, 193, 13, 175, 151, + 211, 32, 196, 109, 28, 171, 31, 133, 149, 60, 93, 190, 218, 98, 241, 113, 85, 104, 155, 31, + 107, 150, 56, 105, 198, 141, 142, 63, 37, 98, 176, 229, 96, 55, 21, 74, 44, 36, 83, 120, + 76, 51, 108, 173, 87, 186, 116, 198, 143, 60, 40, 183, 251, 35, 254, 41, 26, 142, 212, 128, + 39, 194, 235, 114, 43, 255, 94, 123, 63, 171, 130, 188, 17, 41, 3, 21, 12, 67, 176, 217, + 219, 81, 93, 143, 255, 133, 13, 57, 219, 217, 62, 107, 186, 188, 251, 15, 52, 153, 94, 155, + 213, 176, 182, 25, 230, 187, 168, 200, 23, 165, 128, 171, 130, 174, 119, 245, 87, 65, 135, + 246, 107, 116, 94, 159, 47, 113, 6, 24, 97, 155, 199, 145, 134, 245, 137, 21, 2, 217, 149, + 16, 16, 53, 166, 182, 78, 58, 101, 22, 249, 118, 132, 30, 203, 227, 225, 240, 135, 228, 1, + 185, 137, 41, 185, 251, 125, 60, 190, 16, 8, 43, 67, 105, 166, 148, 11, 78, 134, 243, 228, + 205, 136, 81, 161, 195, 58, 14, 13, 52, 228, 208, 253, 120, 161, 79, 117, 238, 75, 226, + 225, 179, 35, 126, 109, 122, 78, 231, 205, 3, 164, 93, 239, 249, 113, 224, 150, 239, 92, + 209, 221, 74, 203, 116, 68, 42, 118, 142, 64, 229, 240, 243, 193, 243, 200, 114, 250, 56, + 40, 234, 206, 159, 160, 247, 6, 88, 99, 123, 5, 61, 31, 113, 141, 228, 27, 176, 185, 212, + 245, 15, 108, 1, 74, 148, 106, 224, 130, 165, 69, 38, 197, 35, 124, 126, 74, 142, 113, 91, + 85, 28, 222, 42, 129, 0, 42, 48, 43, 194, 253, 53, 213, 75, 227, 99, 85, 236, 53, 137, 13, + 156, 93, 55, 119, 165, 104, 235, 218, 204, 164, 30, 218, 49, 8, 120, 103, 99, 2, 2, 116, + 105, 154, 246, 66, 55, 130, 135, 42, 143, 35, 76, 219, 197, 163, 42, 166, 65, 239, 187, + 163, 61, 128, 74, 29, 68, 137, 9, 237, 212, 240, 157, 4, 156, 95, 192, 124, 204, 165, 209, + 125, 178, 227, 180, 208, 225, 63, 135, 156, 31, 231, 137, 81, 158, 202, 11, 77, 238, 242, + 213, 87, 144, 14, 109, 216, 235, 246, 85, 141, 142, 182, 135, 88, 169, 59, 167, 123, 160, + 133, 199, 134, 251, 101, 76, 169, 253, 9, 234, 89, 127, 50, 123, 126, 14, 172, 115, 19, 68, + 196, 98, 88, 100, 241, 171, 108, 239, 65, 12, 67, 88, 234, 12, 164, 249, 17, 64, 148, 193, + 56, 132, 150, 115, 105, 35, 38, 70, 241, 119, 69, 14, 155, 140, 109, 92, 107, 6, 96, 36, + 28, 59, 23, 186, 115, 175, 106, 186, 218, 190, 151, 72, 221, 58, 29, 172, 35, 69, 188, 234, + 102, 146, 183, 76, 106, 61, 232, 194, 179, 93, 71, 141, 42, 234, 17, 20, 131, 52, 162, 126, + 255, 242, 88, 71, 98, 119, 203, 214, 188, 191, 94, 200, 195, 170, 221, 52, 121, 194, 201, + 156, 79, 102, 38, 132, 176, 225, 248, 234, 168, 145, 225, 76, 104, 50, 37, 47, 17, 221, + 123, 40, 94, 19, 252, 129, 157, 198, 195, 252, 59, 45, 144, 94, 85, 83, 114, 155, 77, 200, + 73, 80, 231, 225, 5, 124, 43, 140, 87, 28, 121, 193, 83, 106, 217, 211, 115, 69, 166, 152, + 67, 56, 169, 160, 52, 156, 161, 212, 61, 73, 54, 217, 22, 53, 243, 168, 201, 118, 114, 70, + 168, 182, 144, 66, 140, 110, 144, 104, 78, 223, 192, 15, 144, 65, 175, 44, 133, 99, 68, 78, + 201, 130, 10, 248, 169, 103, 62, 196, 255, 142, 212, 206, 199, 192, 203, 29, 173, 64, 223, + 24, 173, 49, 16, 84, 182, 236, 100, 174, 98, 108, 155, 251, 183, 96, 221, 92, 188, 118, 62, + 226, 76, 107, 217, 23, 74, 178, 148, 124, 139, 7, 75, 126, 21, 16, 75, 244, 178, 197, 86, + 216, 197, 129, 61, 73, 15, 64, 63, 189, 205, 179, 168, 101, 144, 187, 1, 153, 215, 130, + 144, 242, 141, 4, 207, 15, 31, 148, 250, 188, 85, 195, 229, 23, 126, 243, 92, 55, 86, 62, + 97, 17, 207, 101, 112, 33, 148, 10, 125, 111, 33, 40, 124, 18, 250, 172, 219, 61, 150, 197, + 154, 210, 82, 134, 53, 100, 85, 228, 80, 6, 49, 56, 17, 147, 140, 32, 47, 23, 234, 238, 46, + 189, 186, 137, 196, 170, 138, 161, 192, 163, 176, 198, 222, 128, 94, 47, 26, 17, 60, 13, + 89, 74, 202, 116, 210, 69, 151, 212, 120, 175, 118, 164, 204, 177, 50, 149, 230, 39, 50, + 96, 30, 110, 133, 188, 116, 186, 198, 237, 5, 70, 208, 92, 183, 73, 147, 222, 96, 101, 74, + 113, 60, 153, 195, 18, 9, 43, 192, 138, 140, 121, 44, 244, 211, 63, 155, 123, 195, 7, 67, + 52, 247, 177, 253, 82, 71, 245, 201, 51, 129, 122, 15, 25, 129, 110, 49, 63, 169, 232, 205, + 55, 199, 236, 238, 173, 28, 15, 190, 103, 177, 61, 245, 243, 96, 109, 130, 99, 222, 6, 91, + 195, 115, 22, 253, 236, 112, 93, 164, 223, 17, 107, 208, 159, 111, 21, 69, 251, 139, 15, + 116, 171, 144, 235, 216, 128, 106, 162, 122, 43, 100, 88, 81, 205, 182, 133, 27, 165, 125, + 92, 100, 128, 102, 46, 128, 82, 95, 15, 44, 192, 41, 249, 48, 240, 179, 112, 34, 209, 128, + 196, 233, 28, 6, 35, 51, 64, 221, 50, 164, 76, 32, 16, 142, 90, 102, 84, 94, 153, 141, 235, + 142, 204, 119, 37, 225, 71, 42, 33, 171, 182, 190, 239, 50, 194, 204, 28, 181, 242, 43, + 108, 96, 203, 229, 164, 148, 171, 80, 228, 196, 249, 191, 103, 219, 66, 100, 199, 92, 37, + 237, 220, 3, 35, 114, 138, 203, 108, 249, 243, 138, 47, 158, 178, 222, 137, 200, 132, 98, + 87, 119, 217, 111, 174, 16, 78, 85, 191, 129, 122, 226, 4, 110, 223, 107, 236, 210, 66, + 133, 10, 218, 174, 122, 175, 169, 102, 207, 89, 255, 66, 185, 101, 246, 126, 195, 34, 253, + 218, 241, 171, 213, 83, 136, 184, 229, 54, 182, 41, 79, 139, 158, 21, 59, 59, 150, 181, + 245, 133, 190, 61, 145, 115, 72, 122, 199, 76, 39, 168, 212, 170, 194, 136, 25, 218, 158, + 165, 102, 46, 126, 205, 124, 27, 189, 107, 155, 136, 255, 181, 210, 223, 232, 61, 175, 69, + 245, 253, 192, 176, 227, 100, 146, 192, 88, 229, 117, 243, 238, 46, 148, 54, 216, 136, 6, + 76, 122, 220, 101, 82, 128, 167, 172, 205, 209, 37, 33, 95, 224, 28, 243, 133, 43, 88, 254, + 39, 80, 60, 180, 187, 234, 59, 42, 191, 70, 234, 110, 244, 153, 56, 86, 178, 230, 121, 69, + 178, 201, 213, 57, 168, 222, 249, 61, 187, 182, 125, 158, 191, 168, 155, 230, 52, 191, 142, + 219, 139, 79, 121, 235, 152, 106, 123, 154, 33, 155, 158, 134, 113, 188, 161, 75, 164, 177, + 210, 114, 218, 85, 54, 211, 162, 51, 13, 192, 167, 127, 210, 134, 254, 169, 213, 112, 23, + 82, 55, 163, 44, 128, 198, 160, 85, 34, 22, 144, 158, 66, 141, 184, 1, 5, 19, 59, 62, 63, + 141, 212, 22, 228, 229, 8, 11, 27, 45, 147, 249, 253, 8, 15, 38, 39, 56, 91, 114, 129, 158, + 210, 217, 227, 23, 71, 106, 115, 154, 218, 221, 234, 242, 244, 9, 57, 63, 90, 106, 176, + 204, 0, 0, 0, 0, 0, 0, 0, 0, 8, 11, 18, 30, 40, 47, + ]; + assert!(check( + &message, + &sk_bytes, + &expected_pk_bytes, + &expected_sig_bytes + )); +} + +#[cfg(feature = "dilithium5")] +#[test] +fn test_dilithium_c_sk() { + let seed = [ + 200, 132, 131, 30, 183, 0, 227, 121, 200, 85, 77, 25, 211, 136, 179, 122, 142, 25, 240, + 195, 140, 135, 32, 4, 152, 55, 216, 58, 176, 148, 132, 42, + ]; + let expected_sk_bytes = [ + 20, 199, 113, 103, 132, 4, 176, 73, 161, 118, 59, 6, 26, 255, 139, 152, 121, 134, 86, 62, + 94, 168, 58, 30, 146, 8, 177, 115, 249, 19, 115, 134, 125, 227, 180, 73, 148, 115, 2, 183, + 252, 73, 48, 234, 245, 204, 213, 56, 210, 102, 164, 18, 67, 236, 121, 81, 125, 198, 134, + 228, 23, 193, 92, 94, 86, 1, 84, 186, 169, 238, 173, 199, 190, 243, 55, 141, 68, 228, 154, + 96, 38, 10, 202, 11, 222, 179, 15, 235, 39, 229, 208, 80, 158, 119, 136, 41, 139, 168, 109, + 34, 48, 110, 74, 34, 33, 129, 38, 0, 162, 66, 5, 154, 32, 108, 84, 198, 144, 210, 164, 44, + 194, 182, 37, 161, 34, 8, 99, 56, 144, 128, 132, 104, 82, 56, 78, 75, 48, 68, 209, 18, 42, + 32, 69, 69, 161, 32, 38, 217, 72, 81, 88, 38, 32, 33, 56, 4, 203, 36, 146, 67, 32, 109, 12, + 7, 42, 225, 48, 8, 0, 23, 48, 3, 128, 45, 90, 64, 145, 138, 40, 48, 212, 178, 141, 17, 195, + 32, 36, 19, 68, 82, 178, 72, 203, 162, 41, 18, 153, 45, 9, 195, 9, 212, 36, 41, 228, 162, + 105, 66, 38, 41, 217, 56, 78, 1, 18, 130, 4, 165, 36, 98, 40, 14, 28, 0, 97, 218, 4, 48, + 74, 72, 34, 212, 144, 81, 82, 40, 66, 219, 16, 44, 208, 136, 8, 200, 56, 68, 16, 71, 33, + 80, 166, 108, 203, 152, 45, 33, 4, 14, 156, 24, 48, 132, 54, 114, 131, 4, 34, 202, 148, 1, + 218, 36, 0, 224, 16, 82, 67, 180, 112, 99, 56, 108, 64, 18, 80, 4, 24, 110, 194, 50, 77, 3, + 145, 96, 12, 40, 18, 92, 54, 70, 82, 164, 97, 8, 177, 96, 17, 162, 132, 18, 1, 105, 161, + 18, 145, 32, 52, 34, 218, 200, 12, 36, 57, 68, 10, 50, 42, 27, 196, 64, 64, 38, 137, 28, 2, + 76, 26, 36, 113, 217, 16, 108, 0, 146, 4, 25, 24, 146, 225, 56, 12, 74, 40, 14, 209, 164, + 33, 192, 146, 72, 32, 162, 0, 10, 130, 69, 24, 5, 48, 24, 32, 104, 139, 160, 128, 16, 40, + 44, 129, 40, 66, 10, 137, 132, 0, 149, 112, 96, 64, 13, 228, 70, 74, 28, 66, 40, 35, 1, 42, + 84, 52, 98, 163, 38, 0, 66, 130, 97, 28, 35, 138, 3, 192, 112, 4, 169, 16, 19, 195, 145, + 128, 18, 13, 212, 24, 130, 154, 72, 36, 194, 180, 9, 201, 48, 80, 153, 34, 106, 152, 152, + 113, 99, 38, 36, 90, 54, 81, 136, 196, 33, 10, 201, 9, 75, 22, 10, 161, 18, 141, 162, 166, + 77, 4, 38, 112, 2, 51, 44, 137, 196, 16, 100, 2, 144, 27, 33, 65, 67, 0, 50, 153, 192, 97, + 91, 68, 50, 66, 146, 137, 24, 169, 32, 8, 64, 40, 28, 66, 102, 3, 57, 44, 12, 39, 69, 136, + 160, 8, 192, 54, 96, 34, 40, 5, 76, 150, 140, 27, 35, 114, 33, 3, 66, 227, 70, 44, 0, 66, + 48, 218, 54, 9, 218, 152, 137, 10, 73, 69, 131, 54, 98, 9, 134, 100, 76, 130, 9, 163, 68, + 65, 81, 64, 1, 210, 4, 8, 212, 52, 130, 224, 4, 34, 16, 57, 68, 19, 35, 96, 211, 148, 105, + 225, 70, 70, 80, 168, 108, 75, 198, 128, 9, 50, 74, 65, 64, 50, 203, 160, 64, 156, 32, 5, + 67, 24, 97, 64, 48, 130, 139, 200, 68, 84, 182, 105, 32, 64, 134, 17, 4, 65, 131, 200, 16, + 226, 66, 104, 0, 73, 109, 200, 34, 32, 20, 0, 48, 164, 66, 100, 155, 4, 18, 195, 54, 46, 0, + 201, 45, 88, 40, 46, 129, 68, 142, 8, 5, 18, 24, 73, 74, 0, 1, 41, 33, 72, 77, 84, 52, 142, + 203, 66, 77, 75, 18, 8, 99, 36, 10, 216, 24, 6, 196, 192, 109, 147, 0, 132, 4, 20, 100, 36, + 65, 106, 24, 34, 96, 9, 128, 109, 34, 4, 17, 18, 24, 41, 24, 56, 130, 136, 36, 110, 92, 24, + 14, 160, 196, 141, 144, 52, 100, 88, 38, 17, 26, 145, 108, 162, 52, 40, 90, 40, 36, 33, 71, + 141, 36, 200, 44, 200, 16, 70, 211, 52, 68, 11, 132, 65, 219, 150, 113, 9, 39, 64, 27, 145, + 32, 34, 185, 81, 226, 66, 138, 148, 24, 44, 193, 38, 80, 139, 6, 64, 160, 182, 112, 16, 9, + 69, 193, 32, 73, 8, 152, 77, 84, 56, 114, 136, 150, 108, 192, 0, 129, 1, 57, 113, 34, 37, + 141, 163, 182, 77, 19, 131, 141, 163, 2, 4, 3, 21, 49, 216, 196, 141, 129, 2, 18, 25, 18, + 102, 83, 18, 130, 224, 8, 36, 19, 25, 146, 195, 160, 12, 220, 40, 104, 73, 6, 144, 209, + 134, 5, 132, 130, 41, 92, 18, 69, 20, 145, 97, 97, 184, 108, 211, 0, 144, 4, 132, 104, 4, + 137, 140, 65, 200, 32, 10, 2, 78, 11, 131, 64, 26, 161, 104, 28, 0, 1, 227, 20, 73, 9, 137, + 41, 72, 180, 49, 140, 32, 16, 161, 6, 77, 3, 33, 44, 17, 52, 129, 132, 40, 44, 226, 50, 66, + 220, 50, 101, 20, 72, 46, 96, 56, 40, 129, 136, 129, 203, 56, 134, 216, 132, 113, 36, 55, + 96, 16, 67, 129, 80, 0, 32, 192, 38, 145, 220, 38, 46, 208, 162, 133, 128, 200, 97, 34, 7, + 98, 156, 8, 2, 10, 67, 105, 228, 4, 97, 20, 49, 13, 35, 185, 133, 156, 36, 78, 201, 16, 18, + 217, 72, 73, 16, 69, 97, 84, 150, 108, 9, 7, 36, 11, 49, 74, 211, 20, 49, 211, 2, 82, 4, + 73, 146, 164, 164, 0, 12, 71, 144, 35, 7, 5, 20, 20, 82, 227, 48, 106, 92, 6, 50, 218, 160, + 16, 228, 50, 109, 128, 192, 65, 9, 22, 82, 98, 2, 105, 28, 164, 9, 67, 130, 41, 227, 68, + 18, 162, 52, 37, 209, 132, 104, 3, 18, 108, 81, 40, 9, 24, 193, 104, 129, 22, 8, 228, 38, + 40, 10, 146, 113, 34, 132, 9, 129, 34, 140, 8, 16, 134, 18, 193, 73, 4, 176, 65, 192, 4, + 77, 68, 0, 81, 161, 134, 12, 26, 178, 48, 82, 66, 18, 156, 176, 77, 76, 134, 137, 162, 56, + 37, 64, 176, 65, 210, 132, 48, 137, 6, 38, 212, 166, 49, 4, 9, 134, 140, 66, 45, 220, 0, + 100, 0, 194, 133, 220, 132, 17, 196, 2, 144, 100, 54, 64, 75, 18, 4, 90, 48, 70, 17, 73, + 145, 65, 34, 145, 33, 135, 108, 26, 6, 66, 18, 24, 9, 2, 147, 33, 19, 32, 64, 89, 128, 12, + 74, 130, 129, 212, 70, 132, 162, 16, 4, 76, 160, 5, 34, 66, 6, 4, 35, 98, 137, 24, 110, + 194, 6, 134, 130, 134, 68, 75, 134, 141, 0, 5, 64, 224, 68, 82, 155, 20, 14, 83, 192, 44, + 208, 56, 132, 28, 128, 44, 24, 17, 133, 164, 66, 65, 192, 54, 74, 74, 182, 68, 140, 182, + 40, 196, 182, 36, 75, 196, 49, 193, 184, 17, 154, 166, 97, 16, 182, 65, 66, 0, 42, 81, 2, + 96, 96, 68, 97, 66, 18, 144, 8, 49, 110, 96, 194, 4, 64, 130, 137, 0, 56, 10, 164, 16, 38, + 82, 48, 128, 35, 164, 32, 35, 179, 45, 131, 68, 72, 68, 70, 32, 153, 38, 146, 129, 136, 49, + 225, 64, 129, 226, 182, 100, 76, 182, 97, 96, 132, 141, 4, 193, 128, 89, 50, 48, 193, 134, + 136, 2, 135, 5, 80, 200, 140, 211, 2, 40, 27, 167, 45, 210, 6, 108, 217, 4, 134, 83, 150, + 0, 228, 152, 68, 72, 40, 78, 225, 66, 132, 219, 150, 77, 19, 67, 110, 152, 198, 72, 138, 0, + 65, 228, 22, 133, 193, 40, 141, 28, 9, 146, 146, 16, 70, 148, 70, 68, 224, 6, 97, 195, 168, + 17, 11, 48, 137, 64, 152, 77, 84, 182, 109, 34, 67, 145, 20, 135, 77, 219, 198, 36, 12, + 199, 73, 219, 16, 105, 1, 54, 37, 225, 16, 16, 73, 36, 76, 16, 18, 81, 96, 4, 9, 66, 134, + 49, 16, 196, 12, 8, 67, 65, 2, 4, 46, 146, 34, 144, 136, 50, 97, 32, 184, 105, 74, 162, 69, + 82, 166, 9, 2, 194, 41, 2, 145, 144, 147, 48, 48, 36, 35, 38, 156, 66, 114, 203, 134, 1, + 162, 72, 74, 18, 48, 9, 155, 178, 97, 8, 53, 5, 9, 176, 73, 11, 70, 33, 97, 68, 77, 193, + 24, 109, 201, 200, 64, 147, 130, 68, 10, 4, 132, 210, 66, 76, 8, 67, 18, 138, 24, 70, 194, + 54, 97, 138, 160, 17, 156, 8, 136, 84, 20, 44, 194, 182, 12, 202, 144, 49, 27, 146, 105, + 24, 69, 145, 16, 53, 9, 36, 68, 129, 26, 49, 112, 144, 134, 37, 226, 72, 80, 225, 54, 33, + 196, 50, 45, 128, 22, 13, 211, 180, 72, 224, 128, 17, 219, 130, 168, 237, 198, 117, 0, 153, + 95, 134, 169, 163, 9, 26, 171, 209, 20, 151, 225, 16, 253, 45, 76, 239, 164, 180, 68, 241, + 10, 1, 226, 181, 45, 125, 173, 160, 124, 191, 103, 241, 5, 133, 80, 124, 206, 167, 99, 21, + 168, 199, 192, 181, 31, 128, 61, 234, 55, 35, 25, 203, 127, 235, 66, 201, 26, 132, 238, 49, + 116, 109, 163, 228, 134, 249, 71, 96, 82, 162, 103, 167, 221, 208, 162, 224, 57, 248, 173, + 163, 136, 34, 19, 174, 144, 251, 110, 146, 141, 223, 206, 96, 233, 151, 38, 229, 84, 201, + 97, 152, 14, 50, 70, 62, 189, 111, 238, 220, 67, 51, 43, 104, 222, 109, 59, 187, 2, 193, + 31, 44, 133, 201, 70, 24, 143, 159, 230, 1, 1, 254, 253, 65, 165, 11, 40, 50, 178, 191, 48, + 57, 220, 155, 76, 166, 239, 247, 198, 6, 231, 156, 42, 183, 106, 58, 28, 107, 176, 0, 97, + 156, 113, 59, 105, 152, 20, 167, 102, 128, 231, 130, 65, 196, 116, 185, 179, 128, 195, 144, + 137, 190, 251, 242, 139, 199, 40, 203, 40, 54, 201, 31, 10, 139, 248, 14, 155, 81, 4, 20, + 18, 232, 93, 253, 99, 117, 46, 139, 116, 194, 124, 122, 176, 168, 204, 55, 181, 165, 200, + 137, 30, 199, 133, 180, 43, 173, 167, 14, 253, 228, 9, 49, 179, 144, 45, 95, 43, 108, 64, + 64, 66, 226, 195, 75, 64, 78, 107, 130, 236, 33, 132, 7, 207, 154, 191, 96, 227, 44, 65, + 183, 4, 181, 199, 101, 31, 164, 185, 127, 5, 210, 163, 65, 162, 80, 218, 17, 150, 147, 238, + 250, 190, 216, 19, 37, 217, 242, 53, 140, 139, 178, 19, 108, 134, 238, 28, 48, 50, 147, + 251, 15, 47, 53, 179, 123, 168, 208, 173, 191, 51, 166, 22, 188, 138, 43, 127, 105, 64, + 191, 46, 214, 221, 58, 27, 161, 94, 75, 34, 41, 76, 84, 98, 221, 80, 238, 26, 64, 103, 77, + 151, 231, 47, 176, 29, 197, 49, 227, 59, 159, 48, 17, 198, 47, 180, 32, 168, 166, 123, 128, + 74, 119, 165, 252, 24, 172, 76, 125, 227, 17, 99, 116, 24, 133, 41, 117, 217, 111, 245, + 120, 79, 253, 51, 7, 95, 229, 18, 151, 68, 22, 80, 63, 81, 222, 170, 125, 68, 143, 180, 29, + 48, 200, 184, 55, 241, 54, 227, 73, 212, 167, 113, 54, 233, 116, 204, 115, 83, 150, 180, + 75, 244, 174, 223, 60, 112, 132, 255, 92, 79, 11, 191, 243, 146, 95, 41, 161, 178, 79, 211, + 106, 241, 31, 171, 253, 4, 50, 231, 37, 64, 24, 95, 196, 195, 66, 34, 157, 146, 247, 118, + 221, 233, 187, 58, 187, 171, 131, 70, 86, 145, 72, 73, 179, 242, 61, 199, 188, 29, 149, + 192, 32, 119, 20, 89, 22, 106, 79, 50, 100, 4, 127, 41, 230, 151, 154, 207, 249, 235, 91, + 58, 133, 102, 23, 242, 126, 208, 29, 82, 69, 211, 80, 5, 242, 14, 245, 244, 152, 195, 48, + 62, 215, 16, 157, 130, 26, 144, 127, 126, 225, 24, 123, 202, 50, 232, 246, 104, 16, 195, + 76, 33, 193, 36, 21, 42, 181, 188, 142, 117, 102, 162, 105, 210, 67, 218, 241, 46, 136, 61, + 80, 76, 129, 90, 47, 194, 137, 189, 245, 0, 0, 195, 144, 143, 209, 231, 211, 24, 17, 221, + 162, 100, 22, 139, 71, 115, 10, 68, 13, 74, 188, 83, 70, 214, 166, 112, 248, 246, 173, 143, + 126, 169, 21, 28, 197, 237, 224, 51, 72, 6, 230, 154, 215, 141, 6, 58, 214, 206, 208, 29, + 167, 139, 223, 136, 49, 81, 7, 111, 15, 191, 78, 193, 233, 21, 115, 134, 179, 207, 106, + 247, 213, 97, 61, 151, 249, 165, 80, 169, 87, 24, 218, 153, 187, 120, 94, 240, 52, 64, 176, + 52, 39, 20, 2, 63, 186, 174, 79, 241, 57, 188, 50, 164, 148, 84, 234, 170, 0, 39, 165, 248, + 19, 102, 135, 161, 220, 240, 237, 93, 190, 57, 246, 35, 103, 109, 122, 81, 122, 200, 173, + 80, 201, 170, 66, 108, 199, 88, 13, 182, 116, 161, 16, 168, 74, 137, 0, 179, 90, 200, 210, + 211, 237, 162, 234, 193, 22, 14, 32, 255, 182, 12, 157, 66, 91, 245, 156, 163, 212, 212, + 82, 205, 22, 109, 61, 99, 108, 185, 198, 160, 159, 186, 176, 236, 36, 226, 132, 42, 109, + 203, 164, 106, 50, 135, 27, 11, 98, 26, 140, 99, 19, 75, 125, 13, 252, 17, 40, 138, 194, + 74, 196, 243, 122, 145, 61, 121, 36, 190, 53, 163, 150, 19, 115, 200, 39, 166, 66, 86, 54, + 198, 248, 19, 216, 63, 160, 64, 245, 19, 72, 115, 12, 117, 158, 58, 212, 229, 218, 94, 25, + 150, 94, 109, 84, 8, 254, 118, 88, 171, 63, 215, 213, 46, 251, 107, 33, 143, 147, 134, 33, + 241, 85, 37, 27, 157, 251, 184, 60, 65, 18, 223, 41, 223, 230, 66, 238, 109, 54, 146, 33, + 145, 205, 174, 51, 42, 165, 47, 20, 97, 90, 235, 255, 191, 99, 36, 252, 176, 206, 28, 57, + 197, 58, 157, 168, 172, 222, 144, 141, 142, 46, 214, 192, 246, 33, 226, 189, 37, 245, 207, + 163, 116, 134, 97, 166, 14, 2, 154, 176, 193, 122, 67, 252, 31, 142, 169, 69, 53, 149, 194, + 95, 87, 214, 89, 10, 147, 93, 203, 154, 1, 219, 165, 143, 55, 211, 1, 254, 83, 45, 129, + 107, 203, 231, 244, 171, 137, 190, 234, 107, 148, 163, 54, 130, 228, 96, 162, 94, 42, 103, + 233, 204, 218, 156, 24, 10, 33, 96, 174, 126, 63, 138, 229, 28, 80, 108, 25, 199, 228, 161, + 234, 162, 23, 37, 119, 199, 63, 185, 187, 30, 100, 110, 75, 105, 194, 124, 229, 206, 132, + 14, 221, 122, 239, 27, 20, 247, 164, 121, 25, 229, 70, 245, 20, 16, 1, 247, 2, 85, 207, 61, + 17, 155, 250, 108, 242, 55, 201, 114, 154, 254, 45, 122, 137, 199, 190, 113, 46, 221, 59, + 47, 243, 150, 58, 97, 226, 244, 56, 172, 197, 57, 87, 129, 227, 158, 88, 111, 167, 35, 88, + 79, 128, 112, 76, 171, 218, 37, 199, 107, 212, 230, 104, 198, 121, 155, 84, 23, 72, 142, + 33, 139, 89, 138, 208, 110, 252, 31, 80, 13, 98, 8, 159, 76, 217, 180, 158, 239, 35, 57, + 104, 91, 118, 5, 0, 13, 34, 166, 214, 143, 201, 95, 127, 190, 225, 101, 235, 215, 169, 35, + 90, 15, 167, 118, 217, 208, 67, 229, 38, 236, 0, 171, 134, 191, 227, 18, 238, 16, 64, 164, + 202, 231, 121, 78, 73, 207, 108, 99, 173, 252, 25, 5, 135, 179, 102, 202, 21, 195, 27, 139, + 184, 140, 134, 103, 115, 8, 202, 66, 217, 226, 95, 8, 246, 192, 193, 64, 135, 204, 86, 233, + 4, 244, 176, 75, 93, 157, 122, 111, 13, 17, 151, 80, 82, 89, 211, 27, 187, 48, 220, 144, + 244, 200, 239, 227, 224, 197, 192, 70, 213, 83, 41, 144, 16, 156, 30, 97, 106, 143, 142, + 120, 211, 130, 189, 178, 109, 223, 43, 26, 121, 3, 66, 42, 49, 40, 249, 125, 249, 78, 160, + 121, 111, 37, 51, 11, 214, 22, 186, 72, 60, 217, 12, 118, 55, 24, 123, 212, 167, 7, 116, + 44, 26, 195, 219, 109, 28, 115, 48, 231, 37, 61, 177, 66, 133, 0, 72, 181, 203, 190, 159, + 207, 104, 216, 118, 136, 69, 13, 213, 220, 70, 151, 138, 252, 232, 252, 174, 6, 210, 76, + 114, 154, 124, 7, 97, 124, 25, 25, 37, 89, 200, 125, 198, 32, 211, 142, 255, 174, 84, 57, + 62, 161, 40, 23, 253, 250, 186, 32, 102, 34, 31, 85, 91, 144, 139, 28, 179, 44, 195, 78, + 35, 60, 187, 7, 50, 235, 178, 239, 113, 89, 149, 68, 207, 191, 48, 83, 45, 0, 22, 169, 113, + 137, 50, 64, 158, 234, 128, 54, 231, 107, 46, 75, 150, 162, 190, 106, 68, 19, 102, 174, + 103, 135, 245, 11, 84, 79, 86, 109, 94, 128, 214, 97, 178, 171, 191, 62, 246, 186, 66, 174, + 34, 254, 46, 247, 80, 94, 179, 164, 97, 123, 255, 164, 231, 139, 242, 201, 36, 3, 27, 190, + 154, 138, 85, 99, 91, 151, 215, 112, 191, 186, 150, 187, 136, 24, 251, 161, 109, 250, 145, + 94, 204, 81, 202, 117, 229, 47, 153, 191, 226, 111, 225, 223, 85, 151, 38, 161, 22, 46, + 133, 35, 226, 82, 77, 46, 148, 128, 255, 243, 23, 210, 29, 243, 39, 204, 57, 93, 26, 239, + 212, 110, 29, 226, 123, 207, 27, 198, 251, 77, 48, 243, 127, 129, 227, 20, 133, 237, 97, + 66, 139, 42, 235, 21, 21, 215, 164, 206, 179, 1, 230, 61, 25, 2, 91, 224, 242, 35, 126, 21, + 74, 79, 212, 240, 74, 94, 188, 24, 70, 117, 242, 6, 181, 73, 241, 218, 113, 67, 70, 14, 30, + 80, 195, 72, 99, 130, 69, 55, 73, 42, 19, 221, 222, 83, 135, 36, 11, 73, 24, 7, 233, 130, + 204, 183, 60, 29, 75, 75, 187, 125, 6, 9, 202, 226, 176, 97, 36, 236, 24, 162, 154, 7, 53, + 129, 157, 234, 254, 19, 107, 204, 203, 27, 28, 26, 37, 100, 35, 4, 11, 140, 118, 220, 21, + 24, 153, 2, 240, 197, 126, 134, 137, 236, 227, 141, 212, 211, 156, 7, 38, 239, 38, 62, 118, + 170, 151, 149, 32, 6, 182, 13, 217, 171, 241, 178, 74, 48, 74, 140, 86, 71, 130, 86, 249, + 183, 228, 250, 91, 143, 96, 230, 28, 84, 154, 148, 57, 76, 21, 44, 85, 140, 153, 196, 119, + 250, 203, 171, 65, 232, 232, 154, 242, 233, 84, 184, 150, 174, 222, 82, 13, 142, 217, 138, + 63, 220, 54, 158, 209, 17, 99, 248, 140, 249, 15, 109, 68, 223, 181, 230, 44, 107, 4, 138, + 253, 240, 112, 43, 221, 48, 27, 70, 250, 114, 169, 85, 189, 125, 146, 12, 155, 210, 252, + 108, 46, 215, 89, 22, 194, 112, 185, 92, 248, 105, 229, 95, 69, 76, 171, 172, 2, 175, 204, + 191, 92, 246, 141, 191, 177, 69, 108, 21, 20, 243, 42, 162, 122, 71, 39, 60, 115, 201, 11, + 213, 46, 128, 168, 172, 183, 3, 230, 44, 46, 101, 160, 165, 199, 28, 203, 109, 70, 71, 47, + 231, 128, 183, 238, 72, 1, 18, 22, 97, 223, 33, 88, 117, 197, 189, 183, 153, 3, 93, 194, + 240, 244, 96, 90, 200, 94, 21, 67, 178, 151, 153, 218, 132, 71, 78, 137, 181, 39, 218, 6, + 190, 75, 137, 130, 118, 123, 236, 2, 109, 67, 190, 203, 12, 155, 198, 169, 60, 88, 108, 86, + 235, 117, 209, 134, 61, 122, 80, 106, 26, 73, 29, 76, 45, 147, 105, 179, 65, 103, 149, 202, + 108, 198, 106, 165, 78, 111, 220, 6, 175, 63, 16, 112, 1, 148, 213, 173, 4, 59, 99, 74, + 236, 105, 107, 46, 18, 230, 205, 28, 117, 113, 48, 105, 34, 6, 237, 57, 31, 164, 192, 227, + 148, 193, 104, 32, 88, 230, 1, 150, 87, 222, 15, 192, 151, 250, 90, 151, 126, 65, 116, 161, + 195, 157, 39, 186, 31, 172, 176, 168, 212, 45, 64, 203, 198, 69, 164, 39, 195, 185, 123, + 19, 127, 44, 165, 71, 22, 45, 157, 76, 41, 181, 37, 93, 227, 98, 211, 167, 88, 42, 211, 77, + 109, 252, 237, 48, 57, 239, 205, 142, 159, 187, 69, 14, 192, 223, 144, 14, 113, 201, 91, + 178, 254, 170, 27, 63, 252, 190, 59, 84, 25, 22, 172, 18, 42, 9, 160, 69, 226, 224, 17, + 201, 53, 34, 2, 166, 253, 208, 66, 248, 244, 159, 178, 29, 242, 193, 252, 75, 86, 26, 75, + 165, 6, 253, 36, 200, 107, 201, 192, 196, 108, 195, 140, 245, 233, 68, 167, 14, 232, 130, + 71, 87, 194, 93, 177, 41, 7, 183, 52, 156, 56, 168, 20, 95, 58, 32, 189, 130, 187, 64, 240, + 188, 165, 127, 116, 167, 132, 140, 66, 12, 115, 95, 193, 71, 108, 173, 23, 49, 12, 74, 177, + 71, 234, 175, 44, 113, 186, 68, 64, 9, 14, 94, 124, 55, 208, 227, 192, 174, 94, 80, 61, 48, + 149, 80, 95, 72, 101, 225, 149, 228, 175, 35, 148, 53, 197, 14, 152, 93, 182, 184, 40, 221, + 187, 71, 106, 58, 208, 149, 186, 32, 219, 44, 246, 119, 197, 233, 204, 8, 255, 97, 251, + 154, 51, 156, 233, 41, 45, 254, 132, 178, 26, 189, 50, 237, 147, 142, 206, 25, 29, 101, 31, + 131, 35, 159, 211, 251, 196, 219, 141, 104, 227, 124, 97, 131, 79, 149, 10, 209, 134, 193, + 35, 213, 83, 219, 227, 190, 124, 23, 236, 249, 35, 243, 162, 52, 30, 203, 4, 46, 224, 20, + 173, 106, 80, 97, 103, 183, 114, 8, 103, 242, 95, 238, 169, 201, 80, 118, 243, 74, 181, 89, + 148, 44, 248, 175, 7, 63, 26, 65, 37, 42, 68, 126, 154, 196, 124, 85, 146, 168, 133, 123, + 152, 87, 211, 163, 240, 148, 217, 232, 247, 237, 66, 172, 6, 214, 239, 214, 12, 202, 0, 45, + 18, 243, 94, 26, 149, 145, 144, 181, 110, 160, 244, 130, 255, 120, 226, 206, 250, 245, 254, + 33, 117, 172, 95, 41, 225, 18, 194, 55, 142, 86, 182, 213, 106, 7, 3, 171, 20, 231, 85, + 200, 201, 94, 185, 13, 185, 191, 83, 144, 219, 51, 10, 58, 43, 102, 234, 234, 204, 248, 35, + 112, 65, 76, 110, 252, 9, 115, 184, 200, 15, 30, 214, 106, 168, 125, 75, 202, 113, 82, 24, + 250, 196, 103, 179, 105, 210, 73, 252, 138, 104, 151, 6, 55, 46, 134, 17, 93, 72, 171, 2, + 239, 55, 138, 146, 162, 163, 89, 240, 200, 74, 232, 126, 218, 133, 224, 105, 79, 4, 109, + 189, 159, 150, 128, 67, 170, 121, 232, 168, 209, 177, 219, 23, 169, 65, 36, 214, 162, 148, + 177, 149, 146, 253, 134, 36, 163, 2, 208, 116, 93, 97, 123, 76, 115, 79, 147, 214, 47, 234, + 165, 70, 107, 135, 94, 11, 53, 124, 228, 28, 70, 147, 196, 27, 41, 229, 113, 183, 54, 74, + 75, 126, 8, 154, 175, 219, 129, 19, 15, 142, 161, 155, 176, 4, 245, 114, 231, 160, 249, + 210, 214, 7, 125, 111, 188, 170, 25, 226, 43, 205, 202, 115, 252, 246, 18, 16, 122, 206, + 216, 35, 35, 27, 236, 104, 196, 233, 48, 110, 41, 121, 89, 211, 195, 140, 165, 183, 119, + 150, 101, 98, 233, 236, 120, 155, 226, 76, 192, 227, 110, 242, 194, 91, 75, 216, 68, 78, + 58, 243, 80, 48, 150, 42, 215, 100, 170, 250, 159, 216, 112, 243, 245, 76, 201, 80, 123, 3, + 212, 121, 194, 177, 19, 201, 208, 205, 224, 86, 164, 59, 234, 103, 15, 153, 139, 149, 22, + 150, 131, 94, 53, 102, 175, 2, 56, 179, 18, 247, 140, 157, 17, 80, 94, 207, 116, 166, 71, + 235, 60, 192, 19, 249, 255, 185, 236, 128, 162, 112, 210, 55, 56, 22, 252, 210, 182, 107, + 83, 136, 46, 184, 203, 82, 229, 55, 37, 38, 218, 107, 175, 122, 20, 194, 11, 82, 178, 183, + 144, 253, 147, 103, 22, 151, 137, 29, 97, 236, 9, 1, 253, 187, 135, 243, 220, 85, 246, 17, + 133, 20, 208, 82, 132, 106, 124, 39, 62, 65, 185, 6, 250, 127, 244, 119, 74, 83, 170, 186, + 50, 101, 153, 69, 233, 44, 58, 38, 225, 133, 173, 89, 30, 120, 237, 85, 40, 44, 26, 173, + 246, 111, 59, 176, 91, 145, 36, 113, 73, 68, 3, 127, 116, 25, 33, 21, 6, 19, 187, 238, 48, + 180, 58, 231, 61, 234, 237, 95, 154, 17, 14, 79, 229, 25, 38, 191, 224, 181, 58, 99, 87, + 27, 177, 25, 78, 46, 163, 99, 223, 163, 36, 0, 242, 104, 127, 170, 124, 58, 3, 158, 67, + 170, 125, 58, 28, 171, 240, 95, 251, 194, 147, 223, 224, 122, 163, 155, 216, 167, 51, 49, + 3, 221, 248, 99, 168, 138, 31, 77, 85, 185, 70, 150, 12, 94, 183, 235, 251, 52, 228, 101, + 191, 198, 70, 253, 45, 175, 84, 7, 216, 4, 114, 46, 40, 49, 18, 9, 49, 221, 50, 13, 13, + 218, 235, 136, 119, 140, 247, 237, 218, 191, 93, 86, 190, 80, 39, 231, 70, 73, 236, 12, 35, + 23, 174, 231, 190, 7, 37, 129, 233, 9, 179, 211, 154, 116, 117, 213, 237, 251, 210, 55, + 213, 250, 48, 30, 58, 244, 23, 88, 38, 240, 115, 19, 21, 59, 32, 85, 160, 45, 241, 94, 57, + 243, 143, 231, 130, 183, 21, 87, 16, 77, 16, 0, 17, 118, 171, 251, 145, 76, 92, 245, 171, + 149, 48, 20, 30, 51, 61, 175, 22, 238, 240, 206, 89, 165, 65, 54, 229, 204, 123, 165, 108, + 197, 151, 110, 143, 18, 184, 53, 122, 168, 48, 8, 215, 17, 68, 100, 16, 231, 243, 37, 58, + 205, 21, 46, 158, 55, 186, 76, 220, 179, 128, 115, 44, 28, 184, 12, 240, 193, 230, 194, + 218, 2, 219, 160, 96, 121, 201, 42, 233, 80, 187, 194, 56, 234, 117, 137, 216, 87, 186, + 118, 33, 217, 162, 145, 125, 74, 200, 158, 188, 244, 194, 228, 146, 127, 170, 65, 58, 52, + 158, 245, 108, 91, 122, 177, 79, 201, 133, 3, 8, 47, 243, 148, 209, 61, 36, 163, 139, 14, + 132, 162, 134, 62, 239, 47, 211, 190, 169, 147, 101, 152, 111, 3, 51, 174, 91, 76, 209, + 109, 44, 192, 85, 234, 253, 197, 221, 222, 167, 151, 224, 167, 96, 184, 237, 177, 229, 108, + 148, 24, 54, 67, 125, 0, 12, 198, 72, 162, 218, 108, 42, 94, 205, 222, 16, 229, 30, 143, + 124, 179, 207, 119, 119, 249, 199, 91, 219, 89, 161, 118, 109, 158, 36, 243, 47, 174, 229, + 92, 51, 29, 40, 41, 76, 42, 14, 126, 46, 129, 236, 211, 136, 128, 252, 39, 46, 171, 99, + 208, 93, 175, 21, 0, 111, 69, 87, 150, 99, 48, 147, 253, 104, 127, 245, 15, 149, 17, 199, + 76, 122, 62, 43, 189, 73, 48, 46, 254, 60, 120, 248, 42, 47, 153, 114, 56, 121, 184, 171, + 79, 204, 245, 182, 104, 151, 62, 242, 185, 109, 194, 248, 84, 53, 33, 167, 10, 172, 175, + 154, 238, 173, 216, 247, 221, 203, 9, 183, 28, 42, 48, 74, 144, 185, 196, 171, 173, 208, + 208, 2, 207, 201, 219, 241, 51, 35, 213, 208, 61, 208, 102, 181, 227, 63, 141, 101, 187, + 198, 226, 212, 156, 6, 145, 80, 189, 247, 238, 204, 56, 147, 54, 238, 211, 230, 38, 153, + 103, 155, 57, 32, 254, 189, 88, 122, 110, 6, 123, 3, 79, 35, 233, 204, 226, 213, 109, 116, + 52, 203, 62, 102, 215, 195, 255, 70, 145, 5, 44, 75, 251, 20, 43, 109, 98, 56, 19, 22, 238, + 29, 210, 13, 35, 148, 158, 238, 186, 30, 83, 29, 40, 110, 232, 144, 13, 189, 23, 34, 112, + 72, 107, 62, 97, 138, 121, 10, 87, 108, 95, 229, 146, 224, 227, 154, 232, 52, 178, 95, 79, + 248, 189, 239, 96, 218, 29, 254, 147, 88, 148, 201, 104, 191, 15, 120, 36, 182, 133, 82, + 198, 39, 163, 224, 156, 148, 163, 220, 165, 154, 142, 91, 241, 67, 44, 215, 78, 97, 42, 20, + 221, 243, 232, 178, 165, 71, 165, 6, 88, 107, 76, 117, 111, 139, 30, 20, 33, + ]; + + assert!(check_sk(&seed, &expected_sk_bytes)); +} + +#[cfg(feature = "dilithium5")] +#[test] +fn test_dilithium_c_fixed_sk() { + let message = [ + 160, 192, 43, 176, 40, 193, 194, 125, 198, 223, 240, 129, 74, 181, 123, 169, 47, 253, 57, + 86, 235, 215, 213, 171, 107, 146, 223, 157, 161, 255, 238, 36, 165, 5, 88, 217, 208, 82, + 188, 79, 78, 131, 144, 177, 72, 206, 97, 218, 212, 237, 197, 190, 63, 85, 233, 96, 232, + 250, 161, + ]; + let sk_bytes = [ + 222, 162, 199, 75, 3, 52, 247, 143, 212, 108, 56, 79, 201, 126, 88, 129, 176, 120, 255, 23, + 2, 190, 17, 66, 244, 59, 150, 156, 189, 133, 148, 28, 42, 14, 226, 176, 10, 174, 231, 81, + 199, 124, 26, 150, 251, 225, 201, 220, 13, 181, 166, 60, 183, 121, 24, 98, 163, 173, 249, + 255, 215, 64, 147, 125, 69, 120, 127, 134, 211, 78, 172, 128, 230, 8, 91, 58, 231, 121, + 126, 108, 73, 24, 48, 189, 154, 58, 56, 215, 135, 214, 171, 150, 12, 69, 160, 157, 152, 36, + 141, 34, 136, 112, 27, 7, 17, 75, 32, 2, 211, 70, 105, 17, 145, 136, 20, 162, 113, 4, 64, + 109, 153, 134, 17, 68, 36, 138, 153, 148, 80, 2, 22, 106, 228, 196, 5, 132, 178, 140, 131, + 184, 141, 33, 4, 33, 227, 168, 48, 163, 24, 129, 84, 128, 65, 219, 132, 96, 84, 48, 113, + 136, 2, 0, 216, 0, 14, 25, 71, 48, 26, 6, 32, 25, 181, 36, 147, 150, 1, 160, 52, 72, 163, + 24, 6, 28, 167, 68, 131, 52, 36, 146, 70, 141, 32, 36, 132, 132, 52, 12, 97, 40, 69, 36, + 54, 74, 0, 180, 17, 66, 164, 37, 161, 54, 18, 100, 24, 9, 18, 144, 69, 224, 18, 64, 36, 57, + 97, 217, 22, 69, 202, 198, 13, 11, 180, 40, 32, 160, 140, 154, 184, 40, 204, 70, 18, 34, + 33, 1, 137, 48, 18, 225, 196, 100, 81, 2, 112, 194, 70, 98, 10, 38, 100, 228, 152, 137, 28, + 135, 81, 1, 177, 144, 139, 166, 37, 72, 200, 77, 138, 18, 40, 227, 2, 9, 139, 8, 113, 3, + 22, 45, 0, 193, 41, 36, 73, 110, 139, 68, 38, 4, 201, 16, 192, 148, 101, 153, 0, 17, 33, + 178, 48, 18, 5, 6, 160, 66, 74, 208, 32, 9, 4, 70, 134, 17, 131, 41, 1, 3, 65, 19, 37, 12, + 220, 132, 81, 17, 55, 133, 17, 16, 101, 97, 160, 4, 195, 54, 109, 144, 36, 2, 17, 20, 129, + 11, 184, 136, 129, 136, 45, 11, 34, 76, 152, 72, 104, 144, 6, 74, 195, 196, 9, 192, 176, 5, + 89, 132, 40, 200, 32, 82, 64, 198, 33, 17, 48, 128, 28, 151, 9, 196, 196, 0, 98, 144, 141, + 2, 198, 132, 35, 71, 17, 89, 180, 69, 27, 17, 128, 34, 6, 16, 9, 22, 41, 18, 49, 110, 224, + 148, 112, 203, 22, 110, 1, 71, 42, 82, 72, 36, 138, 54, 45, 138, 6, 77, 204, 22, 5, 32, + 185, 141, 0, 2, 12, 65, 166, 45, 140, 64, 110, 16, 38, 41, 212, 150, 76, 2, 57, 106, 132, + 22, 46, 136, 6, 40, 227, 178, 133, 128, 128, 44, 2, 151, 105, 227, 52, 104, 27, 145, 5, 27, + 37, 77, 138, 8, 49, 195, 70, 140, 66, 56, 74, 18, 38, 137, 217, 178, 65, 32, 197, 0, 224, + 160, 69, 131, 0, 48, 67, 56, 136, 196, 152, 32, 16, 0, 33, 209, 144, 8, 99, 136, 81, 9, + 135, 40, 220, 196, 129, 83, 200, 109, 100, 152, 37, 97, 132, 41, 12, 73, 38, 73, 38, 109, + 100, 18, 142, 219, 36, 1, 136, 24, 134, 202, 18, 64, 9, 55, 13, 83, 2, 18, 208, 64, 137, + 161, 40, 45, 204, 56, 134, 24, 161, 136, 76, 164, 41, 130, 146, 41, 26, 7, 5, 211, 54, 104, + 84, 128, 128, 3, 48, 129, 156, 198, 140, 36, 50, 130, 162, 22, 72, 12, 67, 80, 226, 162, + 96, 226, 178, 76, 224, 144, 13, 17, 20, 113, 3, 33, 46, 152, 180, 4, 164, 18, 16, 196, 22, + 64, 73, 166, 41, 192, 36, 17, 24, 35, 82, 139, 48, 101, 36, 177, 140, 91, 52, 10, 96, 2, + 106, 36, 18, 77, 3, 68, 14, 10, 176, 64, 10, 16, 138, 73, 38, 138, 66, 50, 80, 146, 68, + 105, 224, 194, 136, 26, 201, 36, 212, 184, 5, 138, 152, 68, 194, 52, 1, 219, 40, 108, 27, + 25, 16, 9, 40, 77, 66, 54, 136, 211, 8, 98, 16, 70, 9, 152, 196, 32, 202, 34, 66, 32, 54, + 104, 193, 192, 144, 218, 38, 10, 138, 178, 40, 146, 20, 128, 24, 192, 48, 17, 150, 36, 34, + 21, 14, 155, 54, 72, 16, 37, 134, 3, 168, 133, 74, 144, 37, 148, 48, 4, 88, 32, 10, 220, + 66, 104, 97, 178, 136, 0, 153, 37, 97, 70, 66, 211, 16, 128, 64, 66, 34, 228, 194, 0, 25, + 196, 44, 129, 194, 0, 201, 20, 144, 152, 64, 96, 89, 196, 136, 92, 0, 73, 128, 20, 18, 201, + 18, 37, 216, 164, 64, 64, 184, 65, 88, 40, 81, 200, 54, 109, 204, 128, 44, 65, 160, 65, 82, + 166, 16, 16, 135, 41, 204, 2, 105, 35, 7, 17, 33, 41, 74, 19, 166, 81, 75, 128, 104, 28, + 54, 137, 27, 21, 141, 92, 72, 97, 212, 4, 73, 91, 6, 64, 33, 5, 45, 204, 128, 40, 34, 52, + 0, 1, 40, 130, 212, 150, 41, 9, 129, 37, 0, 5, 108, 4, 148, 69, 146, 0, 69, 202, 32, 146, + 12, 193, 41, 154, 32, 108, 1, 146, 129, 17, 150, 73, 194, 18, 1, 226, 22, 44, 10, 18, 106, + 28, 201, 108, 73, 6, 132, 9, 53, 36, 97, 148, 145, 19, 166, 109, 65, 50, 72, 225, 8, 114, + 26, 163, 104, 137, 64, 142, 34, 37, 0, 20, 22, 46, 19, 3, 65, 2, 1, 49, 162, 136, 97, 28, + 39, 16, 163, 22, 16, 4, 6, 101, 17, 54, 129, 212, 34, 142, 96, 40, 133, 74, 146, 40, 9, 0, + 10, 162, 16, 2, 129, 166, 100, 140, 2, 9, 12, 135, 4, 130, 178, 9, 209, 72, 140, 12, 55, + 36, 145, 54, 42, 128, 168, 141, 144, 134, 80, 138, 20, 145, 18, 57, 82, 164, 68, 9, 74, + 182, 72, 34, 5, 72, 19, 49, 1, 32, 162, 113, 100, 0, 9, 10, 137, 144, 4, 185, 105, 82, 4, + 76, 35, 131, 105, 66, 50, 130, 3, 50, 144, 137, 196, 129, 138, 48, 69, 66, 72, 74, 10, 34, + 78, 82, 6, 82, 139, 182, 80, 131, 40, 74, 209, 56, 132, 128, 50, 66, 226, 144, 32, 9, 165, + 77, 34, 178, 12, 32, 162, 49, 99, 166, 129, 217, 150, 37, 24, 135, 141, 96, 22, 64, 10, 38, + 108, 33, 48, 14, 11, 152, 141, 210, 64, 110, 4, 168, 145, 32, 180, 140, 35, 185, 132, 65, + 64, 2, 89, 192, 96, 98, 198, 96, 195, 148, 41, 145, 168, 141, 91, 0, 72, 212, 38, 50, 65, + 40, 105, 139, 70, 73, 67, 146, 49, 16, 168, 32, 225, 50, 136, 19, 37, 141, 228, 160, 108, + 161, 132, 48, 1, 8, 100, 28, 39, 132, 75, 68, 42, 8, 48, 108, 10, 135, 64, 12, 71, 37, 138, + 40, 136, 155, 2, 69, 219, 50, 109, 4, 16, 144, 16, 167, 40, 208, 0, 70, 65, 134, 112, 80, + 18, 80, 89, 64, 16, 154, 180, 101, 10, 147, 16, 211, 16, 133, 98, 178, 81, 3, 2, 104, 72, + 50, 48, 88, 40, 114, 25, 194, 76, 33, 56, 74, 164, 22, 1, 3, 8, 66, 75, 50, 102, 200, 4, + 108, 145, 200, 145, 28, 145, 108, 216, 132, 49, 1, 73, 5, 26, 49, 34, 18, 5, 112, 147, 178, + 132, 27, 147, 129, 74, 128, 144, 35, 64, 37, 10, 183, 5, 208, 132, 45, 26, 137, 76, 24, 23, + 44, 20, 35, 146, 33, 199, 68, 26, 161, 33, 25, 0, 136, 18, 22, 82, 219, 72, 102, 2, 7, 0, + 203, 180, 0, 137, 54, 128, 98, 20, 66, 0, 134, 33, 10, 40, 109, 91, 200, 137, 36, 147, 37, + 28, 51, 2, 11, 181, 69, 81, 22, 113, 140, 0, 73, 224, 152, 65, 32, 65, 104, 140, 152, 17, + 10, 57, 13, 66, 164, 145, 12, 54, 4, 18, 36, 106, 227, 68, 1, 73, 50, 41, 211, 2, 140, 33, + 4, 132, 130, 200, 109, 8, 181, 76, 33, 131, 77, 161, 72, 78, 81, 18, 100, 2, 49, 65, 34, + 148, 129, 12, 144, 44, 16, 70, 2, 203, 64, 136, 219, 200, 113, 224, 6, 4, 201, 48, 140, + 193, 50, 41, 100, 48, 114, 34, 53, 16, 164, 128, 81, 130, 150, 133, 228, 136, 105, 32, 19, + 5, 195, 64, 97, 8, 35, 78, 35, 137, 101, 25, 193, 17, 145, 18, 145, 18, 7, 146, 99, 162, + 13, 209, 50, 144, 33, 21, 112, 19, 50, 105, 224, 176, 72, 3, 151, 128, 20, 180, 0, 84, 68, + 33, 128, 168, 41, 216, 54, 110, 74, 136, 73, 164, 4, 72, 18, 169, 33, 24, 24, 78, 90, 66, + 112, 80, 132, 81, 18, 168, 108, 137, 184, 8, 227, 18, 133, 90, 184, 109, 204, 196, 16, 154, + 54, 138, 26, 20, 48, 138, 164, 72, 8, 70, 50, 217, 198, 49, 140, 50, 106, 4, 57, 137, 17, + 134, 13, 18, 22, 1, 0, 50, 100, 90, 217, 180, 171, 125, 196, 21, 188, 7, 211, 19, 64, 82, + 69, 222, 158, 32, 21, 93, 2, 240, 83, 140, 145, 7, 109, 171, 189, 96, 48, 4, 233, 163, 39, + 217, 222, 1, 205, 55, 33, 34, 18, 56, 235, 19, 151, 88, 7, 231, 176, 240, 20, 24, 193, 162, + 214, 113, 200, 202, 157, 51, 55, 231, 108, 165, 144, 235, 69, 73, 23, 218, 51, 250, 103, + 48, 17, 108, 179, 155, 128, 157, 142, 251, 38, 207, 108, 222, 126, 48, 212, 129, 117, 89, + 133, 38, 116, 248, 178, 38, 111, 67, 110, 117, 145, 74, 182, 114, 196, 49, 22, 215, 142, + 246, 185, 127, 217, 98, 156, 127, 194, 201, 163, 74, 10, 209, 173, 240, 236, 217, 189, 123, + 120, 185, 65, 126, 61, 83, 77, 102, 83, 21, 35, 73, 54, 30, 102, 27, 144, 98, 66, 255, 62, + 120, 147, 255, 193, 45, 190, 135, 119, 100, 85, 250, 109, 221, 45, 176, 90, 242, 67, 237, + 165, 222, 217, 36, 71, 49, 251, 249, 30, 37, 35, 200, 100, 110, 211, 214, 78, 9, 182, 44, + 205, 139, 28, 198, 92, 25, 150, 114, 80, 190, 231, 227, 167, 26, 234, 208, 74, 137, 133, + 42, 250, 180, 51, 56, 161, 190, 117, 140, 251, 122, 92, 69, 24, 15, 173, 30, 183, 14, 111, + 78, 238, 208, 202, 76, 171, 251, 204, 22, 160, 149, 135, 113, 171, 49, 39, 219, 63, 223, + 192, 71, 87, 177, 145, 53, 119, 225, 48, 42, 181, 244, 92, 213, 183, 252, 75, 150, 223, + 220, 6, 108, 176, 11, 221, 232, 247, 134, 201, 55, 199, 133, 41, 22, 82, 202, 95, 43, 184, + 75, 255, 85, 69, 111, 175, 0, 84, 68, 22, 167, 179, 146, 9, 141, 50, 97, 180, 91, 63, 101, + 120, 46, 237, 122, 243, 122, 18, 210, 229, 153, 119, 78, 198, 118, 253, 9, 97, 79, 250, 9, + 43, 231, 10, 48, 1, 32, 78, 248, 191, 58, 75, 30, 5, 172, 7, 71, 251, 224, 86, 217, 226, + 56, 21, 233, 139, 93, 65, 165, 181, 214, 223, 134, 84, 145, 116, 227, 180, 165, 207, 124, + 68, 176, 231, 15, 67, 176, 157, 189, 83, 39, 150, 199, 153, 66, 184, 112, 239, 118, 76, 85, + 158, 10, 235, 188, 166, 194, 251, 65, 152, 20, 20, 66, 228, 199, 33, 89, 187, 253, 154, 81, + 233, 106, 136, 119, 107, 107, 174, 45, 239, 42, 154, 239, 251, 182, 34, 7, 42, 7, 179, 81, + 140, 82, 185, 74, 98, 129, 104, 26, 128, 239, 184, 154, 157, 62, 69, 253, 43, 59, 236, 206, + 194, 209, 10, 148, 226, 111, 174, 221, 70, 100, 254, 241, 179, 63, 4, 127, 91, 81, 189, + 126, 157, 249, 20, 193, 109, 0, 92, 99, 122, 43, 193, 84, 65, 165, 166, 245, 194, 211, 243, + 119, 214, 96, 131, 253, 42, 178, 237, 162, 62, 241, 165, 40, 84, 96, 37, 209, 185, 64, 254, + 192, 210, 239, 91, 165, 248, 99, 253, 129, 213, 119, 12, 107, 35, 62, 182, 192, 146, 140, + 7, 81, 255, 169, 208, 139, 242, 28, 183, 26, 240, 20, 21, 39, 235, 112, 195, 232, 25, 208, + 176, 202, 79, 125, 60, 85, 72, 91, 8, 106, 110, 181, 212, 206, 133, 72, 84, 98, 231, 135, + 40, 208, 210, 71, 148, 248, 37, 159, 30, 158, 233, 189, 248, 185, 48, 158, 197, 218, 255, + 116, 41, 102, 26, 78, 173, 49, 42, 253, 47, 30, 186, 59, 167, 39, 242, 49, 121, 116, 75, + 91, 111, 198, 170, 36, 80, 0, 120, 71, 5, 214, 73, 191, 232, 181, 30, 96, 14, 20, 185, 235, + 249, 220, 219, 123, 13, 154, 23, 178, 98, 235, 220, 212, 42, 111, 240, 6, 252, 233, 240, + 226, 241, 215, 3, 218, 69, 37, 26, 84, 242, 228, 251, 36, 111, 175, 244, 73, 254, 122, 161, + 80, 192, 88, 191, 22, 133, 118, 224, 60, 12, 150, 203, 169, 133, 238, 144, 249, 124, 48, + 184, 79, 26, 55, 254, 234, 36, 100, 94, 114, 79, 64, 83, 156, 85, 187, 171, 166, 59, 78, + 128, 64, 67, 253, 184, 49, 25, 129, 129, 58, 60, 148, 87, 48, 238, 64, 21, 5, 13, 89, 168, + 250, 146, 35, 16, 228, 156, 208, 14, 227, 45, 85, 118, 113, 82, 228, 255, 104, 89, 51, 251, + 197, 235, 177, 230, 86, 143, 29, 30, 224, 181, 237, 64, 165, 249, 95, 16, 227, 48, 191, + 123, 104, 113, 233, 98, 56, 178, 222, 22, 88, 228, 204, 161, 218, 13, 108, 205, 169, 86, + 126, 30, 203, 81, 151, 77, 107, 161, 57, 140, 61, 119, 128, 147, 198, 32, 162, 196, 51, + 137, 213, 24, 84, 238, 133, 212, 36, 126, 72, 239, 16, 20, 233, 177, 101, 23, 232, 1, 76, + 239, 41, 59, 189, 162, 220, 76, 159, 228, 221, 175, 117, 106, 200, 166, 237, 155, 244, 176, + 19, 213, 149, 72, 41, 4, 165, 136, 49, 132, 71, 51, 135, 59, 169, 255, 28, 51, 14, 197, + 135, 110, 178, 207, 13, 180, 67, 181, 68, 2, 230, 35, 117, 47, 234, 33, 165, 120, 189, 251, + 66, 185, 93, 69, 230, 170, 24, 73, 22, 228, 166, 0, 255, 40, 2, 19, 24, 33, 26, 112, 78, + 73, 228, 137, 186, 157, 50, 169, 188, 101, 211, 59, 117, 164, 86, 23, 150, 244, 68, 156, + 231, 111, 185, 240, 22, 184, 54, 86, 159, 46, 121, 176, 54, 28, 117, 129, 210, 169, 172, + 41, 94, 103, 190, 48, 157, 215, 181, 217, 10, 147, 99, 14, 200, 231, 72, 136, 45, 208, 103, + 93, 109, 134, 173, 65, 123, 8, 93, 238, 60, 184, 182, 76, 247, 243, 139, 132, 223, 6, 156, + 238, 214, 77, 178, 176, 185, 145, 77, 190, 55, 14, 42, 237, 250, 164, 128, 41, 147, 160, + 35, 34, 107, 156, 47, 94, 245, 53, 190, 15, 54, 74, 172, 79, 52, 204, 132, 64, 12, 53, 179, + 248, 83, 7, 108, 227, 223, 124, 13, 185, 88, 192, 185, 115, 188, 191, 90, 101, 139, 164, + 118, 44, 212, 193, 239, 74, 80, 0, 41, 152, 65, 14, 134, 136, 80, 51, 11, 219, 17, 251, 88, + 65, 243, 55, 157, 213, 10, 192, 199, 250, 100, 114, 155, 152, 194, 4, 122, 7, 65, 73, 212, + 179, 242, 204, 128, 69, 158, 128, 3, 70, 115, 44, 192, 155, 242, 64, 193, 23, 209, 56, 144, + 40, 29, 129, 208, 171, 103, 172, 194, 97, 117, 198, 107, 251, 174, 103, 75, 215, 97, 114, + 208, 187, 204, 18, 175, 186, 52, 218, 99, 76, 226, 108, 131, 211, 97, 117, 163, 189, 223, + 155, 246, 111, 249, 255, 167, 160, 47, 133, 182, 185, 208, 242, 180, 85, 100, 210, 95, 214, + 163, 218, 178, 30, 127, 82, 189, 27, 252, 3, 50, 57, 118, 73, 181, 218, 207, 82, 241, 223, + 69, 79, 247, 46, 239, 122, 112, 52, 87, 154, 114, 136, 128, 119, 224, 87, 199, 66, 226, 57, + 137, 234, 168, 253, 33, 104, 85, 106, 107, 2, 208, 218, 221, 123, 73, 97, 149, 33, 69, 140, + 185, 118, 204, 45, 9, 165, 181, 244, 241, 107, 40, 23, 204, 72, 80, 4, 114, 233, 122, 25, + 244, 35, 145, 149, 171, 179, 239, 175, 12, 246, 174, 50, 244, 95, 49, 151, 154, 56, 102, + 239, 57, 50, 12, 225, 92, 233, 129, 132, 1, 228, 150, 32, 128, 13, 208, 133, 108, 116, 8, + 191, 182, 198, 30, 69, 36, 141, 77, 253, 196, 171, 193, 22, 229, 70, 55, 117, 72, 29, 45, + 197, 128, 45, 248, 19, 229, 66, 32, 123, 21, 130, 33, 61, 182, 74, 192, 249, 136, 190, 53, + 81, 153, 73, 67, 32, 190, 242, 242, 145, 255, 20, 70, 22, 239, 244, 160, 161, 79, 66, 106, + 89, 219, 13, 116, 238, 8, 51, 5, 47, 68, 232, 38, 103, 124, 165, 47, 225, 72, 36, 250, 43, + 125, 117, 71, 110, 88, 88, 52, 92, 124, 199, 120, 229, 237, 206, 48, 56, 106, 168, 224, + 102, 142, 151, 171, 51, 188, 98, 174, 105, 186, 125, 62, 251, 103, 72, 33, 141, 225, 123, + 238, 31, 116, 185, 72, 8, 198, 172, 166, 54, 91, 183, 211, 200, 93, 177, 254, 195, 48, 123, + 61, 228, 224, 51, 214, 198, 234, 105, 55, 223, 23, 130, 243, 0, 231, 231, 116, 72, 26, 82, + 84, 153, 10, 225, 63, 233, 245, 191, 162, 147, 76, 243, 7, 226, 151, 181, 0, 251, 100, 77, + 200, 180, 30, 215, 207, 124, 137, 24, 232, 158, 22, 106, 21, 118, 6, 105, 197, 56, 175, + 190, 159, 86, 238, 205, 157, 149, 191, 209, 28, 97, 160, 111, 87, 88, 214, 214, 221, 37, + 100, 240, 148, 141, 211, 233, 58, 60, 121, 184, 175, 70, 202, 171, 84, 8, 242, 237, 234, + 223, 177, 68, 119, 45, 120, 208, 240, 48, 220, 178, 228, 250, 41, 215, 67, 46, 147, 201, + 41, 221, 190, 80, 222, 177, 177, 117, 198, 136, 185, 142, 251, 238, 4, 35, 74, 178, 115, + 36, 212, 49, 142, 151, 167, 164, 126, 102, 255, 205, 147, 71, 30, 108, 129, 110, 187, 92, + 231, 80, 230, 202, 79, 223, 94, 167, 157, 228, 27, 215, 38, 91, 140, 133, 140, 89, 177, 26, + 114, 173, 140, 157, 31, 30, 9, 128, 165, 229, 192, 1, 106, 64, 149, 130, 159, 78, 165, 22, + 14, 90, 135, 6, 35, 141, 113, 115, 137, 7, 188, 70, 147, 63, 1, 225, 248, 13, 95, 192, 20, + 121, 42, 13, 136, 135, 15, 21, 177, 120, 13, 30, 152, 244, 252, 121, 38, 172, 243, 41, 163, + 75, 79, 179, 80, 194, 6, 72, 123, 70, 18, 239, 41, 99, 27, 22, 92, 164, 249, 27, 203, 79, + 231, 110, 102, 216, 96, 78, 144, 251, 135, 214, 94, 218, 104, 174, 250, 195, 35, 204, 138, + 27, 221, 106, 3, 110, 142, 125, 71, 35, 47, 157, 70, 53, 132, 4, 156, 191, 140, 106, 45, + 175, 197, 216, 97, 56, 39, 186, 161, 154, 175, 57, 238, 68, 114, 79, 29, 47, 10, 161, 219, + 40, 201, 200, 19, 80, 114, 237, 117, 193, 169, 32, 134, 90, 34, 38, 12, 112, 220, 39, 189, + 250, 9, 74, 103, 118, 108, 110, 247, 186, 91, 49, 135, 254, 45, 76, 134, 66, 100, 59, 59, + 106, 113, 30, 20, 14, 7, 149, 71, 129, 14, 164, 122, 248, 139, 220, 204, 105, 3, 113, 160, + 80, 196, 241, 154, 198, 201, 197, 1, 224, 9, 142, 100, 51, 50, 56, 147, 240, 102, 186, 72, + 89, 5, 238, 78, 160, 43, 103, 76, 115, 158, 90, 154, 67, 45, 89, 50, 28, 153, 142, 222, + 211, 235, 142, 172, 59, 109, 71, 53, 168, 176, 227, 163, 119, 51, 212, 101, 139, 132, 38, + 182, 184, 28, 203, 253, 156, 86, 176, 229, 219, 214, 49, 193, 18, 20, 163, 175, 78, 91, + 154, 60, 165, 5, 123, 189, 152, 132, 60, 78, 18, 130, 67, 109, 242, 218, 4, 232, 189, 162, + 139, 95, 172, 91, 214, 45, 38, 95, 253, 16, 72, 74, 108, 215, 53, 242, 28, 205, 98, 102, + 171, 185, 243, 249, 61, 251, 93, 220, 75, 238, 105, 46, 252, 163, 245, 246, 104, 119, 106, + 253, 98, 176, 0, 180, 215, 173, 110, 125, 45, 126, 200, 149, 1, 158, 14, 228, 55, 201, 71, + 116, 165, 39, 118, 117, 88, 70, 136, 111, 27, 213, 112, 201, 163, 37, 91, 83, 232, 94, 180, + 208, 251, 224, 240, 166, 223, 129, 30, 242, 176, 160, 84, 118, 46, 239, 72, 95, 228, 117, + 216, 102, 23, 143, 117, 175, 48, 163, 152, 204, 248, 33, 109, 31, 93, 202, 254, 65, 75, 34, + 8, 7, 62, 193, 89, 253, 95, 101, 155, 16, 114, 175, 74, 112, 185, 14, 8, 152, 106, 74, 137, + 212, 24, 211, 217, 197, 118, 152, 96, 94, 169, 170, 79, 42, 224, 30, 65, 76, 86, 77, 1, + 166, 102, 95, 26, 239, 172, 195, 168, 22, 118, 118, 186, 221, 143, 48, 247, 122, 175, 207, + 58, 103, 41, 231, 29, 134, 237, 239, 91, 14, 166, 140, 172, 213, 159, 52, 127, 138, 153, + 55, 194, 73, 72, 197, 108, 151, 18, 146, 220, 22, 27, 44, 46, 216, 252, 232, 85, 221, 236, + 137, 135, 204, 217, 220, 159, 203, 168, 150, 90, 146, 123, 40, 91, 190, 172, 222, 165, 235, + 40, 218, 185, 73, 192, 68, 195, 57, 76, 41, 77, 90, 244, 112, 207, 172, 140, 215, 177, 50, + 146, 78, 137, 163, 230, 1, 151, 36, 231, 31, 22, 77, 126, 64, 154, 215, 209, 96, 169, 79, + 88, 8, 103, 198, 121, 198, 152, 207, 205, 89, 98, 172, 166, 35, 111, 214, 184, 121, 216, 8, + 161, 92, 213, 46, 35, 177, 16, 194, 196, 224, 143, 2, 110, 3, 98, 182, 204, 214, 140, 232, + 145, 148, 189, 217, 135, 12, 129, 105, 144, 102, 126, 122, 32, 201, 88, 50, 130, 82, 181, + 168, 100, 119, 216, 98, 108, 247, 90, 249, 188, 226, 175, 204, 161, 53, 56, 98, 69, 173, + 63, 53, 160, 142, 206, 108, 104, 121, 130, 41, 10, 16, 157, 66, 245, 92, 99, 5, 46, 105, + 64, 84, 175, 244, 21, 138, 64, 179, 199, 152, 58, 191, 160, 253, 181, 162, 33, 91, 53, 243, + 25, 112, 120, 189, 143, 161, 215, 39, 241, 37, 226, 39, 62, 218, 9, 12, 83, 50, 80, 66, 97, + 22, 169, 231, 166, 131, 245, 103, 161, 165, 245, 91, 159, 223, 81, 59, 241, 220, 74, 174, + 143, 153, 9, 9, 177, 127, 237, 96, 180, 66, 251, 226, 9, 98, 19, 230, 123, 223, 150, 170, + 175, 237, 175, 239, 47, 37, 44, 72, 150, 21, 10, 34, 50, 142, 107, 238, 129, 127, 66, 113, + 168, 179, 240, 72, 161, 40, 245, 40, 243, 150, 126, 160, 188, 234, 102, 9, 56, 222, 213, + 136, 246, 68, 252, 82, 160, 155, 170, 175, 158, 84, 205, 141, 189, 115, 227, 181, 91, 243, + 27, 100, 181, 180, 8, 143, 170, 138, 9, 18, 246, 242, 223, 245, 253, 20, 79, 222, 132, 40, + 83, 77, 223, 173, 44, 132, 133, 102, 19, 186, 11, 52, 222, 238, 113, 212, 183, 167, 231, + 139, 181, 18, 245, 52, 248, 220, 197, 16, 34, 202, 14, 190, 179, 127, 227, 164, 0, 133, + 196, 243, 86, 152, 138, 98, 14, 106, 163, 88, 82, 165, 159, 72, 201, 132, 29, 231, 177, + 216, 240, 95, 64, 171, 231, 53, 236, 9, 93, 220, 64, 52, 102, 41, 131, 6, 29, 11, 130, 40, + 104, 7, 73, 189, 125, 146, 191, 196, 242, 64, 163, 173, 1, 35, 93, 138, 70, 230, 95, 140, + 128, 164, 43, 173, 167, 37, 136, 133, 48, 48, 161, 220, 36, 198, 129, 236, 35, 70, 175, 34, + 248, 53, 24, 240, 7, 87, 243, 61, 96, 71, 77, 115, 240, 34, 46, 223, 100, 189, 224, 174, + 207, 56, 202, 246, 123, 151, 221, 45, 218, 149, 160, 239, 137, 185, 209, 138, 25, 79, 138, + 56, 68, 20, 131, 173, 198, 53, 86, 194, 178, 63, 249, 101, 180, 226, 137, 13, 50, 115, 26, + 188, 188, 86, 94, 226, 39, 105, 4, 170, 73, 65, 17, 225, 29, 149, 236, 98, 77, 233, 62, 19, + 130, 155, 143, 116, 173, 251, 128, 189, 146, 45, 226, 68, 227, 143, 114, 37, 150, 15, 85, + 71, 251, 36, 201, 7, 158, 238, 161, 52, 233, 38, 124, 213, 172, 183, 127, 131, 84, 126, + 239, 82, 164, 176, 59, 80, 57, 84, 140, 42, 118, 2, 38, 20, 17, 219, 2, 251, 10, 42, 227, + 46, 131, 166, 64, 11, 211, 243, 123, 203, 142, 211, 165, 43, 81, 198, 159, 189, 105, 255, + 95, 244, 221, 34, 161, 67, 73, 230, 144, 219, 109, 172, 116, 205, 238, 31, 197, 68, 9, 4, + 160, 80, 250, 203, 88, 236, 46, 109, 8, 132, 195, 116, 242, 24, 137, 156, 23, 212, 225, + 176, 224, 176, 156, 150, 5, 58, 144, 196, 118, 53, 25, 46, 120, 128, 231, 146, 137, 213, + 128, 187, 200, 57, 40, 182, 102, 161, 235, 9, 81, 20, 107, 149, 55, 68, 203, 158, 32, 109, + 168, 9, 8, 16, 220, 38, 195, 165, 6, 230, 206, 78, 129, 28, 195, 202, 167, 22, 95, 26, 70, + 82, 227, 243, 177, 203, 9, 166, 99, 13, 15, 78, 219, 180, 75, 154, 169, 89, 152, 239, 223, + 212, 135, 0, 122, 24, 87, 67, 151, 228, 56, 140, 38, 206, 58, 2, 23, 115, 214, 116, 139, + 43, 90, 83, 168, 184, 7, 9, 153, 66, 201, 145, 185, 242, 190, 227, 2, 229, 223, 18, 92, + 243, 220, 20, 153, 146, 126, 213, 178, 185, 173, 110, 154, 242, 217, 229, 55, 19, 72, 92, + 209, 218, 131, 183, 150, 25, 225, 178, 206, 164, 133, 230, 118, 181, 71, 15, 43, 26, 0, + 241, 32, 45, 218, 95, 44, 245, 252, 103, 146, 254, 56, 0, 187, 201, 162, 213, 25, 80, 89, + 206, 43, 4, 33, 251, 102, 18, 140, 68, 243, 233, 174, 238, 2, 223, 92, 57, 218, 141, 93, + 24, 2, 175, 169, 141, 90, 236, 183, 105, 137, 165, 200, 204, 165, 99, 169, 40, 59, 236, + 203, 167, 172, 170, 237, 57, 92, 202, 48, 205, 255, 146, 79, 149, 212, 168, 244, 55, 73, + 246, 91, 22, 105, 129, 96, 177, 148, 238, 226, 131, 3, 154, 64, 89, 145, 118, 79, 249, 77, + 19, 186, 177, 3, 88, 29, 199, 203, 60, 94, 149, 111, 16, 65, 91, 196, 217, 184, 143, 59, + 135, 1, 104, 154, 138, 128, 150, 168, 8, 57, 143, 25, 249, 110, 56, 190, 129, 221, 149, + 112, 192, 140, 173, 69, 147, 51, 52, 42, 93, 60, 149, 201, 53, 106, 201, 125, 209, 199, 40, + 155, 173, 127, 60, 1, 176, 22, 249, 117, 111, 169, 220, 61, 3, 159, 12, 47, 33, 201, 181, + 206, 226, 18, 88, 165, 64, 197, 229, 24, 238, 138, 3, 124, 88, 227, 202, 2, 234, 193, 229, + 36, 214, 219, 142, 94, 99, 80, 52, 37, 83, 141, 92, 72, 179, 121, 235, 6, 224, 162, 100, + 154, 189, 75, 87, 13, 241, 117, 243, 106, 87, 18, 184, 73, 70, 252, 63, 30, 207, 191, 58, + 166, 208, 250, 149, 232, 212, 73, 119, 241, 26, 249, 211, 27, 94, 124, 243, 65, 208, 140, + 20, 73, 46, 79, 78, 131, 35, 135, 1, 248, 194, 210, 65, 39, 114, 88, 12, 207, 126, 142, + 236, 23, 71, 69, 130, 255, 225, 67, 248, 44, 155, 137, 29, 189, 1, 52, 8, 2, 61, 130, 120, + 221, 41, 240, 252, 240, 214, 228, 214, 19, 238, 215, 177, 43, 116, 26, 118, 57, 29, 189, + 145, 227, 94, 26, 156, 248, 236, 228, 215, 25, 72, 197, 148, 77, 210, 109, 220, 203, 46, + 252, 30, 116, 69, 124, 247, 133, 106, 45, 10, 96, 178, 246, 64, 245, 183, 64, 127, 252, + 162, 107, 46, 215, 244, 153, 91, 111, 194, 45, 154, 205, 3, 74, 121, 116, 201, 76, 50, 2, + 11, 238, 238, 133, 3, 32, 60, 244, 57, 126, 168, 182, 26, 235, 87, 152, 197, 136, 95, 99, + 238, 34, 159, 165, 62, 85, 220, 5, 199, 133, 30, 161, 207, 145, 155, 79, 193, 203, 186, + 103, 98, 237, 191, 154, 106, 188, 167, 241, 3, 12, 25, 208, 177, 205, 127, 78, 61, 34, 184, + 225, + ]; + let expected_pk_bytes = [ + 222, 162, 199, 75, 3, 52, 247, 143, 212, 108, 56, 79, 201, 126, 88, 129, 176, 120, 255, 23, + 2, 190, 17, 66, 244, 59, 150, 156, 189, 133, 148, 28, 120, 208, 73, 139, 172, 99, 79, 146, + 141, 170, 35, 75, 82, 105, 152, 238, 53, 26, 8, 188, 214, 7, 33, 1, 85, 235, 215, 246, 151, + 132, 12, 25, 111, 122, 92, 123, 83, 248, 40, 21, 70, 83, 245, 125, 90, 137, 130, 192, 106, + 108, 226, 162, 247, 33, 184, 75, 245, 54, 230, 196, 176, 230, 67, 134, 44, 29, 54, 223, + 138, 185, 225, 122, 209, 39, 164, 107, 253, 29, 149, 230, 19, 179, 10, 28, 83, 169, 220, + 202, 167, 74, 244, 194, 65, 248, 3, 67, 12, 139, 237, 97, 38, 126, 88, 254, 18, 172, 242, + 200, 9, 153, 53, 32, 109, 217, 4, 227, 32, 117, 159, 44, 215, 211, 71, 146, 64, 199, 161, + 139, 186, 214, 172, 34, 225, 99, 38, 32, 39, 56, 174, 251, 7, 132, 234, 69, 145, 138, 240, + 0, 191, 52, 112, 117, 254, 235, 24, 23, 71, 36, 110, 85, 148, 210, 117, 195, 125, 174, 217, + 143, 74, 223, 254, 223, 153, 191, 185, 119, 63, 168, 228, 170, 226, 233, 249, 52, 62, 190, + 246, 37, 19, 71, 30, 230, 100, 105, 132, 51, 215, 126, 246, 254, 50, 125, 132, 108, 216, + 81, 129, 230, 153, 239, 31, 253, 53, 141, 82, 197, 11, 69, 153, 204, 224, 243, 45, 232, 48, + 212, 165, 155, 78, 175, 124, 98, 10, 31, 203, 4, 48, 225, 235, 120, 98, 50, 248, 164, 174, + 124, 244, 109, 236, 71, 11, 131, 251, 222, 91, 64, 157, 217, 118, 88, 22, 245, 44, 232, + 187, 140, 134, 172, 6, 188, 144, 90, 219, 79, 211, 110, 62, 209, 39, 29, 171, 56, 131, 76, + 10, 74, 251, 156, 199, 14, 177, 21, 126, 230, 143, 129, 196, 185, 21, 174, 220, 249, 13, + 120, 209, 2, 109, 51, 130, 12, 126, 224, 172, 210, 130, 155, 228, 248, 236, 117, 15, 144, + 223, 139, 27, 163, 8, 185, 168, 193, 139, 45, 161, 247, 93, 76, 141, 239, 137, 85, 9, 93, + 22, 211, 193, 42, 67, 202, 248, 205, 216, 123, 172, 172, 50, 41, 110, 11, 76, 27, 92, 16, + 234, 95, 170, 64, 74, 43, 211, 122, 15, 15, 162, 193, 15, 151, 16, 38, 221, 174, 86, 37, 6, + 95, 151, 40, 101, 80, 116, 3, 4, 95, 205, 37, 13, 52, 60, 62, 56, 81, 211, 111, 28, 89, + 185, 14, 145, 78, 1, 247, 23, 11, 153, 39, 28, 95, 15, 168, 132, 252, 9, 22, 224, 182, 178, + 88, 212, 59, 189, 114, 94, 50, 195, 223, 137, 189, 208, 147, 80, 192, 184, 227, 91, 201, + 142, 244, 181, 219, 183, 149, 51, 227, 124, 6, 37, 14, 8, 51, 54, 62, 147, 81, 217, 50, 27, + 139, 14, 1, 11, 48, 33, 57, 35, 53, 240, 18, 233, 203, 19, 228, 39, 172, 97, 90, 17, 61, + 158, 139, 14, 226, 112, 28, 83, 229, 122, 89, 122, 45, 99, 129, 22, 66, 81, 174, 110, 133, + 205, 103, 243, 61, 93, 6, 46, 35, 164, 31, 212, 217, 148, 23, 100, 246, 95, 109, 218, 40, + 199, 79, 146, 199, 98, 234, 187, 128, 111, 155, 110, 206, 191, 112, 191, 26, 171, 192, 71, + 124, 84, 118, 50, 68, 233, 65, 187, 188, 242, 65, 171, 232, 69, 227, 208, 202, 74, 164, 6, + 228, 225, 17, 29, 52, 98, 207, 170, 144, 230, 105, 77, 168, 37, 102, 90, 45, 146, 213, 89, + 178, 62, 245, 69, 195, 131, 176, 2, 157, 137, 226, 156, 227, 196, 227, 180, 71, 104, 154, + 197, 255, 91, 2, 20, 85, 196, 167, 26, 207, 110, 223, 84, 164, 154, 109, 182, 69, 198, 37, + 84, 36, 87, 124, 87, 239, 33, 97, 182, 77, 245, 147, 178, 221, 247, 161, 165, 29, 243, 194, + 37, 177, 138, 19, 82, 14, 170, 104, 110, 218, 107, 217, 187, 212, 223, 96, 139, 91, 139, + 17, 71, 13, 91, 252, 213, 40, 8, 74, 107, 113, 74, 98, 218, 41, 179, 150, 69, 136, 12, 16, + 149, 185, 11, 165, 107, 235, 164, 249, 238, 51, 154, 37, 4, 111, 181, 7, 176, 77, 100, 235, + 51, 78, 249, 35, 215, 122, 145, 132, 242, 108, 59, 16, 200, 166, 207, 176, 153, 201, 124, + 91, 130, 243, 68, 238, 164, 146, 131, 115, 76, 85, 173, 157, 99, 71, 216, 85, 186, 187, + 161, 40, 208, 188, 157, 77, 232, 80, 209, 71, 33, 68, 11, 155, 90, 163, 14, 211, 137, 13, + 231, 45, 158, 68, 231, 53, 205, 184, 249, 70, 227, 100, 173, 184, 11, 109, 226, 8, 107, 58, + 192, 228, 92, 102, 63, 254, 250, 96, 232, 199, 176, 178, 75, 240, 233, 164, 12, 204, 202, + 218, 38, 49, 103, 122, 28, 165, 91, 213, 123, 158, 110, 177, 168, 154, 193, 163, 18, 170, + 201, 120, 187, 15, 143, 68, 134, 14, 10, 23, 237, 232, 202, 59, 65, 38, 4, 128, 190, 216, + 198, 245, 119, 6, 70, 172, 178, 47, 158, 99, 154, 182, 176, 99, 160, 252, 1, 93, 61, 66, + 178, 148, 238, 30, 123, 103, 225, 132, 194, 47, 52, 197, 93, 58, 164, 241, 137, 184, 42, + 37, 112, 80, 35, 105, 110, 212, 158, 79, 140, 228, 103, 49, 99, 237, 70, 171, 202, 211, + 196, 211, 180, 172, 192, 166, 171, 46, 106, 9, 24, 114, 186, 123, 228, 196, 196, 159, 194, + 205, 148, 167, 200, 142, 216, 40, 101, 64, 160, 120, 30, 171, 162, 222, 12, 106, 227, 215, + 21, 76, 122, 133, 99, 67, 228, 164, 87, 124, 227, 184, 64, 214, 180, 98, 155, 143, 112, + 193, 236, 177, 215, 4, 22, 79, 127, 128, 151, 222, 205, 249, 0, 76, 192, 70, 25, 67, 167, + 242, 121, 220, 44, 115, 235, 48, 93, 17, 23, 250, 40, 1, 241, 178, 19, 148, 50, 4, 128, + 195, 25, 57, 222, 13, 11, 154, 29, 107, 86, 78, 73, 36, 10, 13, 63, 98, 39, 217, 168, 254, + 110, 95, 251, 142, 19, 10, 52, 236, 71, 168, 123, 137, 190, 59, 42, 78, 206, 59, 211, 21, + 202, 110, 163, 229, 123, 144, 45, 71, 0, 94, 211, 128, 253, 73, 64, 153, 166, 59, 168, 26, + 181, 127, 148, 225, 84, 98, 6, 99, 100, 187, 242, 186, 96, 133, 77, 41, 8, 230, 134, 166, + 148, 104, 35, 156, 238, 74, 98, 79, 251, 95, 106, 68, 158, 105, 133, 106, 196, 216, 87, + 114, 96, 124, 185, 151, 21, 199, 143, 55, 90, 129, 115, 255, 20, 52, 164, 206, 49, 152, 78, + 48, 165, 141, 147, 160, 71, 25, 10, 89, 176, 149, 193, 189, 120, 236, 33, 209, 122, 239, + 61, 202, 50, 92, 37, 212, 166, 27, 169, 158, 43, 1, 189, 119, 57, 4, 175, 102, 6, 174, 147, + 228, 194, 9, 222, 169, 172, 197, 237, 246, 31, 206, 81, 23, 45, 151, 80, 200, 109, 171, + 217, 99, 195, 200, 123, 113, 194, 145, 187, 139, 147, 157, 133, 76, 206, 89, 22, 199, 92, + 60, 235, 174, 76, 9, 136, 117, 233, 208, 224, 94, 137, 191, 237, 99, 9, 126, 128, 237, 189, + 242, 4, 100, 36, 107, 73, 188, 189, 67, 21, 230, 55, 21, 55, 60, 225, 215, 84, 131, 149, + 98, 110, 195, 176, 195, 219, 0, 217, 3, 249, 12, 159, 112, 209, 182, 199, 177, 123, 182, + 194, 69, 65, 105, 31, 248, 249, 196, 182, 87, 124, 65, 76, 116, 192, 230, 35, 223, 163, + 214, 84, 72, 187, 14, 13, 24, 84, 109, 100, 87, 32, 187, 217, 12, 134, 140, 247, 71, 24, + 94, 220, 38, 166, 59, 213, 67, 77, 230, 68, 251, 68, 69, 191, 53, 14, 176, 130, 161, 93, + 246, 139, 141, 20, 141, 254, 219, 253, 149, 160, 83, 125, 1, 16, 55, 132, 104, 30, 147, + 243, 7, 7, 214, 114, 150, 102, 217, 38, 221, 161, 186, 92, 113, 112, 20, 243, 57, 112, 200, + 11, 91, 214, 79, 255, 78, 192, 18, 133, 131, 125, 42, 115, 168, 251, 57, 154, 46, 113, 119, + 105, 82, 172, 12, 40, 230, 205, 106, 127, 142, 168, 167, 200, 232, 67, 233, 242, 18, 64, + 47, 84, 192, 14, 6, 232, 33, 145, 12, 53, 228, 179, 57, 21, 77, 171, 184, 58, 67, 68, 53, + 237, 112, 22, 15, 201, 126, 77, 47, 228, 177, 119, 135, 41, 10, 84, 33, 187, 58, 163, 114, + 222, 215, 184, 1, 40, 232, 172, 247, 188, 198, 37, 242, 107, 207, 237, 225, 225, 175, 17, + 206, 104, 222, 111, 171, 14, 229, 58, 181, 65, 204, 198, 119, 115, 107, 70, 218, 170, 71, + 156, 63, 159, 52, 25, 164, 93, 88, 225, 87, 242, 241, 185, 38, 52, 218, 161, 116, 245, 196, + 1, 9, 15, 65, 142, 0, 209, 195, 192, 1, 149, 89, 131, 176, 202, 150, 118, 105, 127, 221, + 196, 114, 113, 216, 145, 37, 212, 75, 42, 38, 236, 247, 119, 142, 213, 114, 196, 44, 112, + 99, 193, 7, 86, 191, 110, 22, 106, 222, 231, 155, 250, 94, 8, 51, 161, 117, 77, 193, 17, + 15, 74, 53, 126, 94, 70, 231, 112, 21, 253, 140, 3, 211, 236, 167, 140, 77, 192, 199, 119, + 180, 41, 89, 58, 119, 97, 184, 215, 192, 242, 130, 19, 39, 55, 249, 145, 244, 240, 214, + 166, 201, 34, 93, 241, 158, 224, 167, 93, 115, 146, 144, 102, 199, 88, 118, 198, 219, 173, + 50, 168, 141, 44, 4, 239, 251, 46, 98, 116, 243, 92, 6, 111, 176, 53, 48, 138, 254, 195, + 231, 19, 104, 241, 20, 228, 106, 249, 16, 150, 233, 192, 124, 1, 176, 248, 157, 176, 98, + 231, 11, 200, 149, 70, 42, 29, 137, 31, 202, 68, 123, 255, 145, 73, 173, 163, 212, 1, 20, + 28, 202, 210, 214, 139, 147, 15, 65, 232, 164, 249, 90, 206, 164, 18, 186, 39, 49, 144, + 235, 48, 204, 185, 158, 60, 157, 68, 99, 251, 19, 49, 115, 160, 185, 30, 88, 248, 255, 129, + 80, 124, 38, 167, 180, 2, 219, 85, 249, 55, 92, 209, 118, 128, 50, 195, 254, 8, 147, 99, + 191, 82, 219, 93, 141, 22, 191, 233, 7, 55, 119, 235, 135, 47, 192, 229, 92, 138, 84, 15, + 169, 32, 151, 119, 83, 92, 82, 98, 245, 227, 230, 27, 62, 125, 168, 231, 78, 150, 192, 154, + 108, 224, 188, 196, 162, 161, 224, 125, 25, 31, 10, 122, 125, 124, 75, 165, 30, 178, 167, + 236, 117, 101, 134, 14, 225, 7, 171, 250, 138, 116, 131, 91, 77, 104, 227, 125, 96, 207, + 246, 247, 112, 232, 62, 154, 181, 126, 215, 213, 194, 226, 215, 32, 174, 127, 24, 52, 236, + 27, 98, 213, 172, 231, 180, 251, 162, 43, 56, 66, 219, 91, 19, 204, 28, 42, 12, 200, 60, + 240, 108, 54, 229, 202, 93, 82, 231, 153, 46, 175, 105, 252, 133, 176, 213, 66, 124, 181, + 252, 70, 43, 167, 210, 196, 157, 194, 117, 205, 92, 35, 149, 151, 185, 7, 174, 160, 205, + 241, 132, 136, 217, 100, 193, 57, 152, 88, 92, 122, 157, 224, 232, 3, 134, 247, 214, 157, + 102, 125, 23, 245, 125, 233, 70, 135, 131, 123, 120, 27, 114, 153, 211, 93, 117, 212, 254, + 223, 230, 224, 166, 204, 119, 55, 214, 245, 8, 18, 192, 184, 45, 143, 28, 104, 252, 242, + 207, 34, 225, 98, 249, 61, 126, 161, 205, 85, 47, 26, 6, 129, 94, 166, 253, 111, 17, 202, + 192, 100, 249, 155, 145, 238, 107, 228, 202, 249, 131, 155, 71, 180, 189, 133, 13, 113, 91, + 133, 158, 59, 223, 149, 181, 3, 135, 147, 125, 200, 211, 120, 230, 70, 138, 185, 147, 43, + 150, 112, 254, 29, 166, 211, 192, 125, 61, 105, 156, 177, 198, 27, 37, 225, 8, 149, 152, + 48, 142, 48, 17, 93, 209, 34, 83, 122, 180, 31, 147, 136, 7, 190, 177, 28, 231, 154, 32, + 127, 236, 221, 164, 157, 32, 233, 247, 113, 129, 66, 204, 181, 17, 153, 141, 251, 14, 236, + 193, 244, 183, 101, 65, 11, 53, 245, 178, 86, 248, 234, 145, 12, 29, 91, 45, 176, 224, 102, + 5, 29, 203, 150, 141, 201, 141, 28, 230, 22, 110, 42, 214, 204, 207, 162, 24, 76, 243, 150, + 139, 22, 103, 244, 224, 135, 136, 66, 171, 176, 177, 91, 75, 71, 149, 232, 129, 129, 121, + 188, 192, 113, 139, 205, 172, 200, 205, 119, 120, 240, 40, 56, 89, 163, 187, 135, 103, 45, + 44, 106, 220, 243, 197, 131, 63, 10, 34, 220, 121, 250, 19, 99, 39, 159, 49, 56, 103, 190, + 181, 34, 93, 81, 179, 90, 160, 188, 86, 164, 76, 1, 204, 106, 153, 206, 236, 202, 138, 32, + 132, 225, 114, 86, 79, 209, 37, 53, 149, 92, 9, 255, 237, 65, 67, 136, 91, 233, 183, 159, + 77, 129, 181, 183, 13, 57, 221, 110, 131, 144, 85, 202, 86, 64, 64, 79, 208, 85, 226, 79, + 153, 192, 126, 194, 16, 30, 173, 194, 84, 119, 88, 164, 130, 115, 95, 147, 175, 190, 41, + 91, 248, 2, 124, 16, 199, 55, 226, 215, 156, 107, 68, 217, 44, 231, 185, 131, 49, 90, 23, + 34, 52, 0, 182, 38, 197, 191, 86, 20, 64, 219, 180, 230, 36, 58, 190, 194, 84, 94, 106, + 240, 181, 18, 194, 176, 218, 105, 185, 238, 200, 53, 148, 153, 30, 228, 18, 159, 49, 213, + 91, 225, 3, 240, 145, 144, 72, 36, 218, 160, 142, 38, 190, 67, 222, 175, 148, 55, 218, 66, + 152, 239, 151, 162, 42, 68, 37, 32, 172, 215, 111, 13, 19, 70, 102, 88, 15, 222, 196, 208, + 118, 113, 85, 232, 208, 236, 63, 179, 235, 2, 172, 114, 243, 39, 48, 92, 70, 234, 190, 56, + 112, 186, 159, 183, 197, 131, 45, 105, 145, 179, 143, 33, 24, 31, 145, 17, 74, 133, 105, + 191, 55, 19, 47, 26, 146, 136, 252, 29, 200, 210, 202, 153, 199, 33, 191, 173, 0, 9, 128, + 93, 210, 98, 206, 186, 188, 144, 218, 188, 211, 218, 178, 76, 104, 241, 85, 132, 204, 114, + 29, 38, 194, 17, 71, 208, 23, 233, 113, 59, 163, 11, 146, 163, 29, 217, 126, 225, 185, 124, + 200, 32, 221, 110, 205, 173, 161, 207, 187, 152, 112, 249, 54, 8, 199, 245, 86, 99, 134, + 81, 109, 244, 61, 185, 224, 199, 230, 218, 255, 251, 174, 91, 166, 109, 214, 166, 213, 47, + 216, 167, 232, 65, 195, 92, 103, 139, 4, 132, 175, 92, 85, 35, 80, 167, 66, 89, 188, 150, + 99, 150, 98, 49, 33, 132, 253, 81, 160, 166, 150, 146, 153, 157, 36, 178, 216, 161, 31, 85, + 72, 236, 0, 105, 82, 155, 3, 78, 149, 82, 68, 234, 236, 50, 144, 168, 185, 212, 215, 18, + 220, 36, 66, 220, 201, 169, 84, 4, 81, 92, 50, 3, 166, 113, 167, 60, 88, 179, 140, 61, 83, + 164, 83, 38, 82, 205, 150, 103, 50, 72, 10, 64, 35, 103, 109, 68, 205, + ]; + let expected_sig_bytes = [ + 175, 186, 184, 11, 243, 176, 160, 39, 210, 215, 182, 93, 193, 96, 67, 163, 239, 76, 45, 18, + 103, 26, 78, 219, 19, 31, 5, 225, 145, 10, 148, 21, 181, 80, 140, 35, 174, 253, 143, 112, + 193, 227, 141, 123, 36, 33, 240, 4, 78, 187, 246, 110, 192, 219, 65, 200, 198, 112, 97, + 157, 44, 6, 239, 26, 144, 208, 160, 22, 97, 198, 36, 22, 184, 237, 75, 29, 34, 72, 46, 60, + 115, 204, 195, 42, 30, 92, 36, 107, 88, 198, 34, 61, 21, 122, 72, 27, 21, 43, 253, 127, + 171, 213, 168, 196, 178, 183, 88, 126, 152, 156, 143, 104, 77, 4, 229, 162, 165, 94, 58, + 242, 66, 213, 121, 155, 157, 58, 216, 140, 38, 50, 160, 233, 193, 182, 16, 10, 120, 59, + 165, 210, 206, 218, 190, 125, 75, 121, 27, 114, 223, 162, 102, 21, 160, 86, 213, 162, 56, + 224, 72, 99, 11, 218, 22, 145, 46, 195, 109, 225, 83, 139, 112, 55, 168, 144, 96, 12, 1, + 109, 99, 28, 64, 87, 133, 46, 78, 148, 215, 85, 203, 5, 109, 244, 242, 101, 107, 65, 200, + 48, 137, 33, 123, 66, 75, 67, 173, 127, 134, 216, 200, 97, 34, 152, 156, 10, 186, 5, 188, + 250, 108, 186, 196, 240, 168, 252, 219, 70, 241, 39, 91, 7, 107, 88, 75, 116, 23, 120, 193, + 168, 206, 50, 115, 25, 62, 196, 186, 195, 118, 124, 25, 92, 226, 117, 243, 77, 209, 92, 3, + 93, 75, 111, 31, 91, 104, 216, 118, 228, 43, 8, 237, 189, 6, 108, 10, 224, 96, 208, 32, + 205, 50, 65, 202, 1, 4, 56, 21, 220, 177, 142, 47, 110, 52, 78, 213, 101, 63, 37, 233, 45, + 106, 46, 38, 0, 16, 229, 111, 90, 200, 154, 150, 148, 154, 119, 115, 9, 96, 165, 168, 22, + 212, 76, 235, 116, 114, 9, 128, 72, 200, 130, 222, 201, 158, 191, 34, 91, 88, 184, 63, 82, + 208, 188, 75, 12, 214, 5, 89, 137, 148, 223, 246, 60, 114, 211, 90, 219, 128, 161, 206, + 194, 122, 93, 141, 153, 32, 113, 32, 156, 131, 231, 20, 70, 85, 178, 88, 23, 185, 217, 69, + 245, 177, 109, 118, 242, 121, 102, 174, 76, 177, 229, 88, 11, 42, 110, 89, 150, 90, 111, + 29, 136, 138, 25, 207, 113, 207, 225, 213, 194, 156, 2, 3, 70, 199, 100, 14, 109, 253, 69, + 16, 185, 243, 155, 102, 232, 142, 162, 101, 49, 24, 49, 250, 161, 226, 188, 153, 228, 208, + 153, 10, 108, 20, 171, 231, 217, 7, 33, 52, 51, 253, 252, 198, 140, 183, 212, 183, 130, + 156, 187, 71, 60, 164, 158, 136, 120, 211, 156, 202, 229, 96, 171, 46, 88, 195, 160, 14, + 188, 27, 237, 67, 31, 209, 255, 133, 52, 207, 58, 201, 243, 159, 9, 162, 221, 184, 52, 191, + 170, 78, 74, 180, 203, 86, 192, 117, 52, 124, 79, 110, 105, 33, 47, 224, 75, 41, 154, 128, + 63, 55, 50, 70, 58, 96, 33, 141, 126, 226, 227, 132, 11, 222, 108, 127, 177, 54, 125, 210, + 201, 231, 142, 85, 29, 232, 114, 109, 48, 177, 194, 150, 43, 10, 223, 25, 160, 143, 76, 76, + 235, 69, 170, 154, 23, 102, 60, 51, 179, 95, 11, 134, 214, 34, 96, 113, 112, 149, 195, 13, + 13, 93, 5, 62, 156, 184, 102, 247, 104, 53, 29, 182, 205, 33, 140, 53, 56, 2, 221, 207, + 156, 146, 100, 76, 67, 180, 183, 211, 37, 98, 86, 139, 201, 5, 75, 1, 149, 3, 98, 9, 196, + 67, 102, 174, 155, 231, 49, 113, 160, 206, 180, 215, 155, 211, 62, 253, 155, 37, 78, 149, + 138, 165, 24, 207, 199, 210, 76, 19, 184, 224, 59, 122, 153, 14, 233, 89, 84, 94, 56, 207, + 67, 242, 200, 36, 233, 30, 235, 150, 180, 193, 188, 127, 30, 78, 190, 230, 227, 54, 84, + 181, 61, 20, 62, 4, 179, 214, 35, 86, 152, 192, 227, 247, 205, 193, 175, 46, 238, 214, 247, + 135, 182, 36, 1, 45, 243, 223, 151, 104, 89, 190, 252, 83, 104, 73, 96, 215, 215, 122, 149, + 172, 90, 197, 32, 144, 14, 112, 92, 141, 106, 7, 105, 139, 165, 117, 220, 10, 185, 120, 37, + 156, 70, 242, 242, 242, 223, 214, 147, 152, 158, 7, 95, 64, 192, 201, 142, 46, 136, 158, + 131, 53, 93, 123, 109, 229, 60, 122, 235, 197, 246, 22, 91, 174, 199, 13, 8, 51, 192, 40, + 93, 210, 72, 75, 207, 176, 55, 121, 238, 126, 22, 19, 173, 96, 50, 47, 236, 38, 4, 209, + 243, 183, 207, 215, 126, 79, 225, 190, 36, 37, 189, 188, 157, 221, 49, 229, 18, 38, 188, + 172, 202, 43, 181, 203, 187, 165, 106, 174, 60, 220, 81, 100, 205, 6, 95, 122, 253, 132, + 177, 189, 33, 121, 220, 131, 185, 9, 179, 13, 137, 193, 213, 182, 1, 59, 59, 231, 228, 203, + 83, 165, 162, 85, 210, 27, 114, 213, 11, 122, 191, 140, 11, 58, 87, 201, 219, 109, 32, 34, + 107, 99, 28, 66, 148, 216, 240, 118, 240, 79, 219, 75, 132, 188, 190, 18, 79, 203, 187, + 138, 14, 82, 135, 59, 21, 217, 244, 60, 211, 136, 32, 168, 252, 86, 52, 44, 38, 217, 233, + 245, 0, 93, 61, 105, 180, 125, 231, 88, 212, 77, 44, 148, 106, 244, 233, 80, 87, 250, 227, + 149, 132, 178, 72, 84, 118, 237, 214, 126, 225, 26, 141, 85, 82, 118, 112, 87, 96, 36, 214, + 137, 135, 81, 111, 171, 203, 141, 168, 133, 193, 61, 8, 147, 3, 220, 163, 141, 90, 36, 31, + 189, 253, 200, 179, 158, 15, 69, 8, 41, 210, 184, 211, 207, 7, 6, 22, 239, 34, 172, 8, 45, + 74, 242, 62, 99, 50, 166, 110, 115, 99, 97, 232, 114, 231, 148, 71, 98, 166, 158, 93, 210, + 44, 32, 192, 24, 197, 64, 168, 173, 134, 188, 222, 195, 6, 184, 78, 21, 175, 183, 45, 178, + 193, 147, 208, 9, 215, 235, 230, 62, 8, 159, 247, 249, 243, 233, 135, 234, 175, 209, 133, + 252, 7, 231, 140, 82, 247, 238, 40, 77, 3, 171, 121, 164, 136, 13, 4, 26, 146, 211, 69, + 223, 11, 108, 7, 117, 36, 195, 36, 40, 155, 43, 210, 23, 176, 139, 113, 126, 3, 76, 114, + 91, 147, 183, 119, 107, 58, 21, 160, 37, 44, 15, 48, 240, 47, 189, 22, 26, 246, 230, 230, + 227, 235, 27, 253, 252, 142, 82, 35, 72, 194, 76, 221, 176, 103, 174, 82, 147, 126, 217, + 143, 112, 90, 182, 251, 202, 86, 145, 146, 204, 234, 102, 229, 241, 197, 187, 251, 48, 62, + 255, 85, 58, 154, 48, 194, 53, 52, 1, 68, 56, 90, 136, 71, 58, 20, 220, 185, 98, 153, 76, + 92, 82, 73, 102, 177, 49, 107, 81, 26, 197, 41, 208, 159, 185, 18, 250, 130, 243, 162, 158, + 117, 89, 126, 61, 147, 78, 237, 52, 144, 212, 164, 218, 200, 109, 203, 223, 151, 218, 43, + 169, 68, 116, 125, 192, 208, 44, 110, 42, 53, 46, 23, 224, 49, 150, 113, 121, 112, 235, 68, + 185, 9, 70, 201, 70, 195, 188, 249, 2, 231, 151, 46, 255, 110, 204, 196, 195, 5, 53, 116, + 46, 205, 5, 78, 202, 22, 85, 157, 249, 106, 87, 95, 23, 15, 10, 176, 132, 165, 235, 219, + 55, 20, 62, 86, 190, 97, 177, 73, 13, 69, 1, 183, 89, 92, 120, 40, 132, 223, 251, 229, 159, + 218, 159, 80, 85, 79, 155, 145, 93, 4, 227, 44, 115, 186, 165, 151, 174, 113, 219, 60, 174, + 83, 100, 28, 145, 211, 164, 240, 163, 24, 59, 101, 39, 0, 67, 144, 40, 121, 173, 152, 97, + 253, 54, 65, 6, 177, 32, 188, 155, 46, 120, 68, 252, 19, 28, 132, 48, 181, 223, 90, 252, + 185, 5, 101, 110, 93, 151, 54, 14, 207, 169, 104, 186, 16, 201, 216, 165, 171, 42, 47, 10, + 20, 13, 81, 197, 172, 187, 181, 66, 184, 170, 231, 133, 51, 100, 21, 7, 185, 150, 128, 243, + 162, 70, 160, 233, 112, 29, 84, 87, 95, 177, 199, 188, 80, 243, 163, 150, 153, 80, 90, 140, + 106, 42, 129, 135, 16, 115, 69, 33, 168, 26, 19, 221, 18, 247, 108, 136, 42, 69, 94, 86, + 133, 141, 80, 78, 233, 237, 81, 153, 178, 39, 249, 237, 51, 162, 220, 129, 87, 109, 109, + 62, 200, 238, 151, 65, 30, 35, 223, 61, 122, 141, 116, 148, 77, 45, 180, 231, 150, 34, 35, + 55, 221, 196, 230, 56, 244, 228, 63, 130, 170, 49, 194, 94, 229, 54, 27, 181, 159, 206, + 133, 193, 254, 195, 200, 155, 232, 80, 138, 84, 48, 12, 135, 39, 123, 144, 198, 187, 13, + 118, 233, 205, 230, 61, 233, 40, 122, 225, 53, 53, 42, 80, 7, 146, 72, 142, 242, 250, 102, + 179, 113, 210, 136, 247, 157, 133, 223, 239, 141, 219, 50, 44, 112, 43, 3, 12, 86, 195, 70, + 138, 12, 210, 141, 250, 17, 142, 161, 20, 50, 63, 243, 69, 220, 171, 158, 4, 120, 7, 102, + 76, 98, 239, 111, 242, 6, 236, 11, 76, 130, 54, 18, 93, 173, 134, 58, 236, 122, 220, 240, + 9, 24, 92, 218, 104, 78, 255, 140, 231, 166, 60, 125, 169, 14, 112, 213, 84, 25, 94, 157, + 177, 60, 77, 69, 213, 226, 92, 116, 95, 215, 123, 224, 57, 169, 250, 192, 250, 177, 126, + 157, 14, 17, 224, 12, 136, 99, 33, 158, 205, 12, 47, 175, 151, 152, 112, 148, 72, 26, 172, + 42, 118, 152, 123, 127, 85, 141, 214, 144, 178, 66, 223, 238, 38, 232, 103, 159, 66, 121, + 135, 146, 174, 223, 232, 86, 66, 228, 254, 200, 184, 106, 1, 118, 121, 128, 149, 49, 38, + 129, 145, 6, 171, 97, 218, 254, 216, 9, 204, 160, 202, 22, 146, 68, 79, 40, 91, 212, 221, + 31, 99, 156, 133, 114, 74, 165, 10, 159, 25, 252, 105, 108, 121, 99, 238, 17, 105, 137, 84, + 55, 70, 179, 162, 101, 174, 97, 47, 94, 102, 100, 235, 75, 51, 247, 243, 85, 139, 24, 199, + 163, 22, 56, 27, 205, 238, 37, 114, 17, 244, 229, 67, 211, 118, 148, 193, 253, 52, 216, + 252, 131, 146, 50, 253, 254, 182, 34, 71, 10, 60, 234, 133, 64, 222, 208, 52, 102, 253, + 226, 168, 29, 121, 23, 242, 158, 227, 242, 45, 120, 0, 95, 220, 216, 240, 92, 196, 174, + 226, 142, 237, 179, 21, 130, 27, 163, 106, 105, 203, 229, 70, 50, 180, 249, 52, 243, 236, + 229, 26, 133, 189, 82, 33, 122, 83, 42, 125, 183, 74, 76, 0, 7, 56, 149, 99, 219, 100, 247, + 217, 193, 16, 197, 180, 174, 103, 32, 216, 135, 248, 220, 53, 4, 160, 190, 1, 0, 62, 102, + 182, 119, 85, 55, 159, 113, 214, 153, 82, 213, 90, 215, 185, 168, 150, 215, 226, 224, 174, + 112, 135, 160, 146, 127, 227, 201, 47, 193, 237, 240, 208, 187, 58, 174, 176, 0, 30, 148, + 201, 248, 210, 119, 60, 143, 201, 110, 55, 47, 221, 108, 145, 108, 236, 42, 125, 197, 54, + 249, 27, 187, 146, 79, 157, 102, 228, 193, 188, 172, 198, 249, 13, 108, 136, 149, 60, 47, + 24, 102, 5, 71, 48, 199, 243, 22, 79, 81, 247, 132, 194, 16, 156, 76, 72, 232, 244, 200, + 191, 75, 115, 164, 228, 156, 152, 78, 237, 91, 70, 167, 14, 78, 32, 89, 111, 60, 99, 183, + 104, 181, 193, 16, 114, 137, 201, 52, 17, 141, 33, 185, 195, 38, 38, 35, 233, 26, 190, 50, + 161, 23, 240, 241, 209, 228, 184, 6, 119, 134, 143, 41, 173, 23, 39, 212, 47, 179, 142, 60, + 175, 96, 12, 254, 237, 206, 67, 57, 35, 219, 177, 188, 53, 93, 132, 185, 123, 32, 42, 39, + 88, 68, 56, 185, 249, 197, 254, 210, 11, 40, 95, 123, 198, 9, 6, 58, 56, 180, 222, 34, 189, + 111, 34, 60, 223, 23, 144, 111, 29, 232, 213, 239, 8, 205, 198, 66, 115, 200, 138, 131, + 225, 21, 209, 185, 45, 248, 71, 164, 111, 44, 198, 60, 211, 3, 75, 96, 71, 177, 75, 247, + 68, 77, 143, 88, 213, 73, 50, 11, 144, 94, 33, 149, 163, 31, 228, 221, 5, 128, 128, 65, 74, + 82, 91, 15, 182, 46, 231, 83, 87, 40, 54, 191, 104, 5, 5, 19, 17, 208, 82, 68, 22, 78, 244, + 45, 163, 206, 220, 74, 84, 170, 80, 54, 126, 200, 198, 152, 208, 223, 81, 235, 148, 233, + 116, 91, 161, 162, 102, 88, 106, 80, 237, 179, 232, 178, 11, 129, 134, 147, 29, 19, 229, + 146, 44, 146, 80, 155, 192, 143, 164, 146, 14, 70, 81, 182, 231, 97, 175, 228, 200, 247, + 31, 158, 90, 123, 221, 15, 184, 67, 154, 190, 225, 212, 229, 94, 171, 117, 129, 120, 161, + 127, 160, 189, 178, 108, 1, 239, 100, 75, 43, 126, 5, 131, 172, 33, 144, 120, 183, 18, 26, + 200, 164, 124, 34, 163, 28, 104, 101, 215, 90, 183, 46, 195, 252, 75, 31, 42, 49, 0, 6, 96, + 123, 65, 160, 141, 67, 78, 91, 216, 139, 9, 19, 128, 14, 171, 98, 138, 221, 209, 244, 153, + 189, 190, 99, 255, 247, 201, 10, 17, 162, 19, 155, 96, 174, 252, 70, 37, 131, 78, 161, 241, + 217, 118, 89, 52, 91, 241, 69, 103, 248, 250, 80, 193, 173, 69, 109, 106, 39, 179, 140, 74, + 6, 117, 180, 206, 123, 197, 10, 80, 138, 29, 232, 254, 179, 230, 184, 72, 203, 227, 118, 3, + 186, 217, 88, 235, 100, 98, 6, 61, 63, 180, 99, 177, 244, 179, 47, 24, 196, 184, 53, 37, + 33, 149, 212, 140, 102, 163, 47, 224, 67, 217, 248, 213, 143, 134, 110, 46, 0, 77, 107, 2, + 161, 212, 214, 123, 41, 104, 174, 82, 247, 30, 247, 98, 193, 28, 218, 172, 127, 153, 37, + 194, 123, 33, 45, 2, 19, 57, 78, 238, 247, 36, 192, 27, 60, 211, 197, 10, 255, 190, 56, 19, + 34, 13, 101, 4, 220, 49, 218, 156, 166, 127, 76, 4, 207, 219, 166, 82, 234, 1, 229, 109, + 210, 157, 230, 13, 67, 240, 152, 159, 96, 143, 16, 11, 92, 84, 29, 177, 246, 165, 137, 123, + 154, 86, 152, 249, 154, 99, 243, 125, 175, 85, 217, 56, 126, 25, 95, 84, 234, 181, 102, + 101, 167, 58, 223, 135, 147, 131, 22, 108, 223, 193, 139, 2, 17, 153, 239, 217, 7, 134, + 197, 224, 149, 1, 178, 2, 147, 99, 83, 151, 198, 156, 116, 129, 136, 85, 120, 132, 32, 70, + 215, 103, 16, 111, 152, 217, 216, 92, 204, 176, 182, 138, 172, 234, 217, 205, 4, 152, 37, + 66, 14, 175, 124, 76, 220, 116, 187, 42, 208, 15, 163, 52, 36, 159, 53, 248, 110, 132, 43, + 88, 241, 111, 97, 90, 79, 89, 191, 58, 38, 18, 56, 211, 118, 144, 65, 92, 28, 217, 210, + 129, 33, 26, 117, 190, 249, 175, 124, 216, 45, 109, 5, 106, 200, 208, 3, 226, 110, 46, 198, + 201, 23, 246, 49, 105, 240, 191, 96, 63, 31, 255, 170, 251, 135, 136, 154, 232, 138, 209, + 73, 198, 3, 32, 214, 85, 18, 48, 117, 253, 220, 61, 57, 221, 121, 167, 23, 48, 145, 243, + 16, 36, 113, 125, 2, 222, 226, 163, 158, 7, 115, 231, 140, 116, 102, 161, 159, 185, 237, + 230, 50, 138, 206, 19, 215, 225, 120, 209, 243, 205, 254, 63, 237, 46, 23, 174, 146, 227, + 1, 50, 26, 216, 82, 121, 65, 33, 77, 6, 9, 44, 100, 240, 76, 155, 10, 123, 95, 6, 47, 187, + 179, 149, 29, 25, 225, 193, 181, 222, 90, 100, 181, 51, 226, 150, 240, 132, 59, 160, 7, 37, + 204, 109, 13, 11, 232, 175, 251, 227, 12, 39, 195, 89, 99, 61, 174, 18, 148, 161, 142, 228, + 204, 232, 152, 209, 252, 232, 184, 76, 128, 234, 254, 163, 253, 66, 203, 163, 167, 200, + 142, 133, 63, 226, 65, 217, 239, 212, 40, 121, 27, 227, 48, 93, 59, 192, 40, 144, 65, 182, + 0, 101, 217, 87, 243, 34, 133, 158, 209, 154, 215, 87, 195, 21, 5, 152, 12, 123, 124, 28, + 87, 165, 55, 111, 89, 157, 53, 156, 6, 214, 129, 104, 120, 137, 12, 26, 42, 134, 226, 107, + 252, 202, 213, 201, 165, 131, 34, 59, 149, 233, 129, 254, 63, 197, 158, 167, 229, 41, 46, + 209, 139, 63, 187, 100, 86, 176, 1, 178, 107, 68, 199, 124, 124, 182, 185, 72, 232, 14, + 140, 174, 116, 242, 122, 228, 74, 143, 229, 113, 131, 94, 197, 155, 126, 125, 212, 57, 238, + 231, 50, 213, 161, 108, 61, 106, 76, 70, 165, 156, 252, 61, 76, 91, 153, 66, 237, 153, 75, + 5, 9, 192, 83, 112, 144, 143, 153, 186, 206, 13, 206, 109, 7, 254, 171, 58, 204, 203, 155, + 19, 174, 220, 251, 78, 134, 1, 109, 83, 124, 217, 147, 111, 188, 229, 156, 233, 43, 39, + 130, 140, 202, 200, 49, 210, 38, 191, 120, 30, 57, 55, 202, 205, 185, 183, 106, 212, 118, + 234, 112, 222, 251, 41, 21, 78, 209, 39, 148, 138, 28, 124, 252, 192, 63, 94, 104, 134, + 172, 245, 172, 212, 68, 130, 134, 178, 147, 49, 193, 126, 252, 225, 158, 212, 189, 97, 129, + 212, 105, 47, 229, 53, 96, 66, 94, 155, 180, 55, 113, 168, 136, 222, 70, 103, 50, 223, 249, + 232, 92, 155, 156, 2, 94, 144, 254, 255, 39, 150, 127, 120, 0, 236, 240, 113, 61, 56, 113, + 206, 198, 74, 30, 155, 150, 63, 16, 202, 28, 215, 27, 148, 62, 67, 48, 162, 161, 255, 179, + 112, 2, 222, 46, 59, 19, 194, 38, 180, 120, 161, 54, 93, 155, 186, 165, 75, 221, 21, 230, + 130, 80, 219, 159, 136, 84, 29, 183, 163, 14, 217, 61, 236, 99, 214, 244, 150, 73, 162, + 228, 132, 75, 107, 184, 208, 32, 52, 140, 174, 99, 250, 115, 26, 3, 202, 185, 246, 66, 23, + 130, 127, 80, 156, 165, 69, 36, 19, 250, 110, 2, 183, 87, 221, 109, 215, 147, 208, 16, 95, + 2, 177, 122, 197, 152, 159, 123, 146, 16, 63, 175, 55, 45, 218, 98, 47, 90, 117, 132, 118, + 71, 220, 212, 73, 94, 148, 0, 121, 78, 234, 93, 98, 183, 86, 57, 115, 68, 169, 192, 193, 6, + 127, 112, 87, 223, 154, 88, 42, 155, 214, 161, 149, 239, 246, 35, 242, 108, 103, 187, 108, + 146, 229, 5, 9, 163, 178, 152, 68, 189, 104, 190, 45, 13, 75, 56, 116, 96, 79, 90, 210, + 119, 242, 251, 200, 0, 52, 164, 19, 191, 243, 69, 95, 70, 213, 119, 107, 181, 32, 112, 13, + 212, 77, 77, 252, 72, 113, 195, 117, 36, 252, 232, 117, 158, 113, 203, 64, 55, 174, 5, 214, + 254, 143, 124, 248, 77, 92, 181, 68, 54, 168, 67, 215, 68, 190, 10, 200, 158, 54, 250, 131, + 170, 203, 216, 44, 160, 235, 145, 166, 170, 73, 148, 15, 209, 58, 209, 174, 244, 140, 219, + 107, 135, 116, 121, 45, 0, 76, 218, 97, 245, 98, 116, 220, 81, 243, 48, 104, 83, 188, 193, + 34, 94, 179, 154, 159, 197, 137, 158, 92, 172, 171, 95, 127, 44, 190, 5, 216, 19, 217, 240, + 48, 51, 186, 50, 67, 139, 175, 68, 119, 121, 87, 146, 35, 58, 0, 65, 167, 59, 108, 74, 73, + 245, 145, 104, 174, 78, 73, 97, 74, 222, 27, 240, 96, 60, 33, 61, 105, 181, 250, 111, 61, + 249, 99, 91, 36, 49, 155, 125, 198, 117, 155, 217, 6, 167, 188, 74, 29, 226, 60, 27, 210, + 101, 179, 181, 66, 201, 8, 89, 179, 238, 20, 58, 133, 58, 105, 160, 29, 132, 53, 2, 97, 12, + 161, 219, 255, 2, 253, 198, 194, 3, 68, 186, 194, 1, 250, 124, 150, 60, 186, 160, 237, 143, + 204, 104, 15, 102, 114, 188, 206, 40, 7, 45, 98, 132, 213, 170, 143, 173, 132, 154, 4, 28, + 67, 219, 208, 215, 25, 119, 200, 15, 132, 236, 26, 235, 172, 133, 255, 125, 166, 155, 221, + 59, 115, 129, 84, 253, 224, 183, 115, 59, 181, 61, 139, 239, 117, 36, 171, 163, 88, 88, + 102, 116, 74, 22, 207, 132, 245, 230, 165, 68, 237, 25, 154, 121, 157, 42, 121, 253, 139, + 40, 248, 59, 11, 159, 94, 216, 71, 76, 92, 55, 181, 26, 104, 121, 45, 61, 218, 154, 77, + 187, 243, 121, 152, 191, 28, 97, 2, 210, 127, 191, 11, 176, 137, 23, 146, 75, 83, 230, 23, + 122, 214, 38, 243, 87, 234, 242, 189, 86, 174, 199, 139, 182, 215, 68, 250, 113, 18, 84, + 161, 193, 247, 66, 235, 23, 108, 136, 179, 239, 94, 142, 0, 7, 198, 63, 119, 173, 251, 78, + 153, 72, 83, 62, 19, 60, 65, 216, 159, 44, 235, 78, 200, 132, 59, 217, 138, 149, 102, 13, + 130, 49, 89, 154, 44, 14, 169, 96, 183, 75, 213, 78, 161, 189, 124, 217, 217, 78, 240, 207, + 195, 183, 100, 184, 97, 99, 150, 178, 218, 144, 63, 73, 213, 192, 64, 83, 220, 137, 46, 95, + 199, 44, 140, 90, 73, 220, 200, 126, 219, 206, 125, 113, 192, 21, 216, 225, 155, 243, 63, + 199, 198, 41, 145, 101, 82, 178, 98, 70, 186, 78, 233, 96, 62, 244, 240, 46, 146, 70, 209, + 92, 4, 10, 5, 144, 31, 246, 246, 26, 196, 125, 239, 92, 0, 147, 74, 172, 148, 3, 173, 242, + 168, 238, 99, 45, 27, 23, 203, 240, 226, 41, 253, 67, 163, 187, 1, 234, 149, 24, 157, 223, + 172, 147, 120, 61, 89, 238, 214, 192, 223, 28, 213, 149, 133, 115, 47, 150, 143, 0, 59, + 220, 90, 122, 90, 204, 18, 32, 90, 57, 234, 149, 6, 22, 133, 143, 37, 161, 192, 255, 204, + 189, 178, 208, 244, 250, 50, 86, 41, 41, 122, 115, 41, 242, 183, 135, 46, 65, 76, 232, 28, + 51, 120, 102, 213, 145, 223, 135, 138, 35, 143, 41, 175, 65, 12, 11, 52, 100, 214, 154, + 151, 92, 71, 13, 190, 31, 65, 222, 206, 160, 3, 42, 114, 27, 85, 107, 104, 34, 191, 178, + 144, 134, 16, 140, 109, 81, 125, 200, 180, 35, 33, 114, 92, 161, 68, 62, 79, 178, 81, 113, + 199, 20, 17, 248, 67, 80, 232, 130, 236, 26, 210, 182, 221, 218, 8, 249, 169, 100, 184, + 251, 134, 29, 22, 32, 78, 115, 147, 102, 24, 196, 225, 24, 75, 163, 118, 190, 121, 136, + 217, 170, 241, 57, 54, 151, 225, 104, 125, 193, 224, 118, 202, 149, 33, 221, 106, 172, 39, + 130, 39, 85, 69, 203, 191, 61, 106, 14, 142, 35, 165, 238, 106, 8, 96, 4, 81, 119, 223, + 182, 185, 129, 176, 82, 252, 171, 84, 40, 43, 31, 231, 134, 154, 140, 132, 99, 175, 91, + 180, 77, 33, 210, 107, 128, 221, 201, 154, 96, 250, 190, 159, 35, 250, 252, 182, 29, 8, + 176, 148, 174, 240, 45, 83, 41, 122, 172, 164, 255, 49, 9, 231, 192, 223, 116, 239, 197, + 54, 0, 227, 114, 236, 246, 60, 31, 110, 156, 127, 187, 215, 248, 143, 49, 57, 120, 181, + 131, 56, 88, 149, 255, 17, 154, 208, 246, 221, 197, 221, 186, 91, 192, 75, 246, 1, 36, 16, + 85, 91, 145, 92, 55, 139, 20, 42, 124, 18, 53, 204, 29, 22, 95, 11, 241, 201, 215, 236, + 154, 90, 142, 30, 78, 49, 84, 221, 45, 235, 104, 152, 37, 218, 135, 154, 98, 171, 29, 33, + 3, 56, 102, 210, 154, 85, 61, 215, 160, 162, 229, 188, 124, 128, 13, 1, 29, 156, 83, 151, + 69, 130, 180, 102, 172, 189, 233, 51, 151, 205, 191, 114, 234, 29, 151, 231, 97, 237, 28, + 60, 249, 112, 230, 217, 94, 181, 221, 151, 232, 188, 160, 175, 71, 213, 186, 194, 76, 137, + 91, 166, 11, 28, 57, 150, 248, 83, 202, 176, 108, 249, 246, 123, 37, 84, 104, 17, 35, 216, + 238, 131, 186, 110, 189, 126, 43, 7, 207, 64, 152, 236, 131, 152, 194, 251, 223, 71, 165, + 186, 33, 12, 249, 121, 57, 48, 150, 186, 117, 85, 90, 38, 23, 19, 69, 90, 78, 57, 89, 238, + 48, 102, 227, 113, 12, 40, 182, 202, 6, 71, 195, 243, 93, 74, 101, 233, 141, 169, 237, 244, + 203, 164, 206, 67, 223, 182, 18, 22, 220, 111, 77, 227, 61, 217, 9, 9, 131, 107, 158, 181, + 25, 34, 70, 102, 204, 167, 202, 186, 157, 24, 116, 134, 118, 166, 248, 72, 117, 64, 2, 79, + 29, 122, 45, 134, 146, 127, 222, 111, 139, 145, 38, 230, 46, 119, 124, 197, 57, 178, 58, 8, + 192, 214, 252, 187, 22, 122, 139, 109, 135, 2, 59, 194, 144, 114, 179, 20, 134, 214, 44, + 225, 17, 28, 222, 106, 237, 89, 172, 203, 202, 241, 106, 207, 8, 131, 143, 87, 84, 188, + 170, 108, 207, 137, 218, 152, 139, 40, 40, 97, 237, 162, 111, 250, 98, 12, 57, 173, 239, + 125, 73, 111, 46, 94, 156, 40, 249, 87, 208, 185, 62, 68, 187, 8, 245, 69, 63, 227, 111, + 160, 252, 165, 105, 138, 85, 191, 231, 144, 101, 21, 244, 145, 85, 102, 135, 63, 160, 56, + 100, 205, 82, 114, 62, 198, 89, 206, 34, 183, 120, 118, 246, 75, 121, 203, 125, 98, 131, + 222, 254, 86, 165, 56, 149, 196, 222, 79, 96, 95, 64, 161, 15, 92, 239, 209, 124, 48, 114, + 34, 37, 162, 221, 156, 158, 141, 220, 249, 160, 184, 78, 69, 190, 38, 234, 173, 112, 145, + 156, 195, 32, 142, 239, 248, 238, 125, 194, 22, 65, 198, 190, 236, 100, 89, 95, 250, 59, + 182, 203, 104, 55, 214, 67, 168, 68, 197, 150, 79, 219, 37, 227, 32, 245, 50, 55, 241, 23, + 151, 250, 75, 71, 186, 32, 176, 28, 240, 247, 28, 228, 102, 238, 53, 51, 242, 75, 237, 179, + 126, 164, 226, 157, 16, 54, 12, 191, 94, 253, 183, 11, 67, 91, 222, 255, 193, 32, 236, 201, + 213, 31, 5, 25, 153, 193, 199, 167, 30, 50, 185, 8, 205, 122, 70, 48, 26, 69, 76, 132, 200, + 13, 241, 209, 251, 84, 163, 252, 207, 4, 16, 33, 163, 132, 136, 149, 160, 168, 210, 46, 62, + 144, 231, 250, 253, 12, 25, 134, 142, 213, 50, 73, 132, 158, 215, 9, 24, 54, 59, 72, 135, + 150, 157, 184, 203, 237, 41, 93, 95, 140, 178, 190, 208, 223, 234, 8, 33, 67, 70, 131, 135, + 136, 144, 146, 189, 0, 46, 74, 76, 90, 126, 136, 219, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 6, 12, 17, 22, 33, 42, 52, 60, + ]; + assert!(check( + &message, + &sk_bytes, + &expected_pk_bytes, + &expected_sig_bytes + )); + + let message = [ + 87, 107, 8, 145, 245, 7, 77, 143, 242, 215, 113, 40, 187, 181, 102, 161, 227, 93, 1, 186, + 139, 115, 48, 195, 149, 56, 19, 243, 83, 127, 205, 67, 251, 85, 235, 59, 29, 130, 157, 26, + 132, 32, 201, 221, 134, 64, 250, 179, 185, 134, 18, 17, 118, 121, 127, 102, 151, 68, 209, + ]; + let sk_bytes = [ + 69, 67, 166, 252, 181, 30, 219, 187, 255, 212, 125, 14, 181, 190, 91, 141, 76, 44, 163, + 248, 133, 22, 62, 168, 194, 114, 50, 223, 158, 28, 15, 151, 168, 249, 213, 74, 8, 212, 156, + 153, 212, 243, 172, 122, 179, 145, 246, 193, 105, 231, 16, 176, 72, 77, 114, 129, 22, 22, + 10, 21, 19, 220, 79, 231, 8, 175, 55, 171, 58, 65, 20, 224, 92, 245, 180, 103, 56, 242, + 100, 198, 3, 154, 160, 14, 161, 46, 126, 206, 192, 130, 91, 238, 244, 195, 74, 92, 1, 199, + 76, 8, 66, 137, 152, 192, 129, 196, 66, 74, 28, 130, 100, 147, 50, 68, 140, 160, 141, 83, + 38, 100, 211, 34, 133, 161, 48, 77, 12, 33, 102, 146, 136, 112, 218, 164, 32, 99, 166, 69, + 154, 178, 17, 3, 128, 65, 97, 150, 128, 131, 130, 136, 164, 164, 65, 66, 128, 128, 36, 65, + 49, 204, 182, 96, 10, 19, 36, 34, 1, 76, 224, 52, 82, 98, 68, 64, 146, 192, 8, 3, 132, 49, + 76, 0, 32, 145, 70, 105, 64, 70, 140, 218, 18, 96, 201, 18, 136, 34, 22, 130, 17, 37, 110, + 160, 164, 105, 9, 37, 106, 20, 35, 106, 35, 153, 16, 161, 166, 17, 194, 0, 77, 200, 160, + 49, 82, 132, 41, 0, 129, 112, 220, 36, 128, 1, 198, 105, 2, 161, 105, 19, 8, 141, 145, 18, + 12, 76, 132, 112, 204, 50, 1, 32, 181, 144, 154, 196, 40, 10, 41, 13, 25, 134, 4, 147, 132, + 108, 89, 8, 10, 27, 7, 97, 9, 23, 45, 153, 2, 140, 8, 135, 113, 144, 48, 0, 82, 162, 13, 2, + 57, 14, 2, 72, 114, 152, 146, 145, 26, 161, 13, 97, 6, 80, 9, 66, 2, 16, 194, 69, 34, 20, + 41, 19, 185, 96, 99, 134, 100, 164, 160, 129, 26, 6, 14, 2, 19, 42, 226, 184, 12, 12, 18, + 9, 201, 0, 9, 210, 48, 2, 147, 166, 140, 156, 196, 73, 32, 72, 16, 128, 130, 48, 140, 150, + 17, 227, 150, 45, 18, 18, 112, 10, 52, 32, 200, 24, 81, 82, 182, 0, 74, 8, 144, 220, 8, + 129, 18, 194, 144, 160, 70, 134, 35, 200, 16, 4, 52, 82, 203, 194, 13, 18, 9, 73, 131, 160, + 96, 155, 198, 9, 129, 68, 49, 36, 131, 128, 220, 18, 33, 10, 184, 100, 192, 34, 105, 153, + 24, 16, 35, 52, 80, 17, 40, 76, 224, 194, 0, 75, 56, 145, 4, 183, 145, 217, 36, 106, 81, + 72, 137, 219, 32, 9, 82, 72, 102, 162, 166, 17, 98, 70, 42, 211, 164, 16, 76, 70, 73, 0, + 146, 37, 147, 200, 45, 129, 180, 73, 11, 180, 144, 72, 200, 13, 218, 182, 0, 73, 176, 13, + 156, 24, 144, 132, 162, 145, 140, 36, 97, 1, 17, 98, 1, 146, 1, 228, 164, 48, 96, 128, 137, + 1, 71, 17, 202, 38, 41, 200, 36, 16, 211, 56, 102, 148, 2, 81, 27, 38, 66, 226, 4, 38, 152, + 194, 40, 140, 38, 140, 88, 50, 77, 11, 65, 80, 96, 200, 33, 144, 24, 0, 24, 9, 38, 20, 68, + 109, 219, 152, 65, 3, 66, 46, 3, 129, 49, 8, 69, 129, 36, 17, 140, 34, 162, 41, 139, 52, + 69, 156, 20, 141, 218, 56, 34, 164, 0, 64, 8, 151, 132, 32, 70, 106, 98, 64, 130, 202, 54, + 141, 160, 66, 37, 72, 148, 112, 19, 2, 64, 24, 144, 40, 67, 2, 97, 156, 70, 110, 74, 38, + 70, 72, 56, 42, 81, 184, 0, 12, 73, 142, 161, 196, 109, 34, 37, 80, 98, 24, 140, 99, 16, 1, + 28, 134, 68, 90, 24, 48, 137, 164, 45, 36, 73, 137, 130, 8, 82, 35, 51, 108, 36, 67, 112, + 195, 8, 38, 24, 145, 77, 72, 168, 0, 2, 67, 130, 25, 71, 82, 68, 128, 32, 65, 166, 137, 1, + 38, 13, 154, 192, 13, 144, 184, 1, 203, 18, 129, 147, 40, 74, 20, 53, 44, 91, 48, 128, 18, + 66, 130, 138, 182, 113, 9, 135, 13, 65, 40, 44, 192, 136, 132, 225, 36, 42, 35, 23, 109, + 220, 64, 100, 84, 178, 97, 18, 69, 102, 88, 6, 64, 208, 36, 128, 26, 132, 132, 153, 6, 46, + 74, 182, 129, 2, 51, 42, 20, 56, 49, 76, 22, 17, 0, 54, 0, 72, 16, 46, 211, 48, 12, 204, + 176, 105, 84, 8, 105, 68, 168, 77, 92, 20, 44, 1, 128, 17, 32, 134, 136, 72, 198, 101, 218, + 70, 32, 128, 20, 128, 228, 152, 145, 152, 168, 129, 81, 148, 100, 196, 66, 114, 88, 200, + 13, 34, 129, 144, 200, 66, 100, 92, 168, 12, 200, 22, 38, 210, 192, 96, 162, 134, 33, 33, + 196, 104, 27, 183, 144, 36, 183, 144, 80, 66, 0, 16, 53, 40, 201, 54, 80, 66, 54, 133, 75, + 24, 144, 164, 134, 33, 193, 4, 46, 12, 185, 36, 33, 0, 146, 164, 2, 68, 12, 137, 73, 219, + 36, 46, 148, 34, 98, 1, 133, 68, 17, 198, 77, 26, 152, 96, 152, 68, 98, 154, 160, 128, 24, + 135, 65, 88, 168, 113, 80, 70, 16, 18, 130, 76, 160, 0, 50, 130, 52, 81, 72, 22, 33, 25, + 69, 44, 80, 4, 80, 82, 180, 64, 92, 130, 76, 91, 22, 14, 152, 178, 113, 92, 40, 145, 137, + 136, 77, 203, 54, 16, 17, 25, 46, 33, 146, 141, 154, 4, 49, 164, 178, 97, 154, 128, 32, 76, + 18, 38, 192, 66, 137, 9, 147, 104, 144, 54, 5, 36, 71, 40, 155, 66, 128, 18, 152, 81, 10, + 23, 37, 227, 152, 101, 130, 196, 12, 137, 176, 129, 20, 33, 82, 139, 64, 41, 10, 16, 108, + 10, 161, 49, 8, 162, 49, 68, 200, 145, 80, 182, 16, 0, 1, 49, 0, 4, 65, 4, 178, 32, 164, + 166, 0, 4, 199, 129, 145, 20, 32, 164, 132, 4, 82, 130, 68, 129, 2, 82, 217, 24, 100, 225, + 178, 65, 84, 180, 80, 34, 49, 77, 140, 130, 73, 91, 54, 2, 163, 176, 96, 18, 48, 97, 10, + 37, 97, 11, 64, 72, 0, 131, 32, 65, 72, 133, 35, 21, 65, 8, 162, 105, 64, 2, 132, 227, 70, + 9, 224, 40, 32, 196, 182, 44, 28, 1, 113, 25, 199, 140, 224, 68, 73, 36, 9, 105, 140, 36, + 37, 216, 56, 45, 192, 20, 46, 34, 128, 105, 200, 68, 106, 96, 128, 33, 36, 72, 145, 11, 57, + 50, 0, 183, 73, 28, 7, 13, 208, 48, 64, 137, 24, 34, 160, 66, 69, 2, 164, 145, 24, 7, 46, + 204, 38, 136, 66, 184, 100, 81, 144, 37, 140, 180, 5, 194, 160, 145, 2, 201, 81, 219, 168, + 1, 34, 153, 128, 154, 16, 77, 35, 36, 10, 35, 51, 32, 19, 57, 133, 224, 178, 112, 4, 3, + 142, 228, 168, 101, 195, 24, 38, 10, 51, 81, 90, 64, 8, 96, 16, 64, 2, 197, 8, 34, 0, 142, + 24, 178, 0, 161, 22, 36, 18, 195, 104, 67, 64, 36, 4, 4, 46, 36, 144, 136, 148, 38, 112, 3, + 177, 0, 35, 128, 128, 220, 40, 98, 96, 184, 141, 156, 32, 48, 202, 38, 1, 131, 32, 100, 0, + 49, 97, 80, 16, 129, 204, 6, 12, 10, 194, 17, 9, 130, 17, 156, 18, 76, 32, 1, 136, 195, + 198, 16, 99, 34, 12, 131, 148, 68, 100, 16, 66, 128, 34, 108, 8, 16, 146, 74, 0, 69, 35, + 132, 129, 16, 40, 141, 8, 22, 38, 2, 37, 129, 140, 54, 17, 28, 195, 96, 2, 2, 40, 17, 2, + 108, 204, 150, 129, 19, 32, 8, 156, 48, 141, 92, 72, 10, 9, 166, 96, 128, 22, 137, 164, + 180, 32, 81, 168, 68, 16, 32, 9, 19, 37, 81, 145, 40, 12, 9, 57, 102, 131, 52, 133, 147, + 66, 73, 140, 152, 128, 195, 162, 49, 84, 34, 5, 225, 148, 136, 81, 178, 17, 65, 180, 97, + 140, 24, 101, 33, 19, 65, 12, 21, 32, 35, 39, 72, 17, 147, 101, 1, 1, 81, 17, 5, 80, 82, + 40, 70, 16, 55, 40, 68, 52, 134, 227, 194, 104, 84, 8, 17, 84, 136, 129, 148, 178, 112, 67, + 56, 66, 131, 54, 77, 33, 68, 66, 131, 168, 41, 1, 20, 136, 75, 160, 96, 3, 160, 81, 96, 20, + 140, 160, 184, 8, 0, 36, 32, 203, 2, 82, 0, 166, 12, 83, 66, 130, 99, 34, 38, 146, 198, + 132, 74, 150, 45, 91, 6, 73, 26, 38, 105, 28, 153, 97, 130, 128, 5, 18, 135, 16, 35, 182, + 65, 201, 2, 42, 3, 192, 81, 147, 54, 102, 210, 144, 144, 99, 160, 76, 33, 131, 144, 0, 137, + 76, 91, 0, 105, 64, 40, 130, 146, 130, 17, 16, 1, 70, 11, 39, 130, 26, 67, 16, 220, 18, + 133, 24, 0, 109, 74, 180, 113, 132, 178, 9, 65, 36, 112, 89, 146, 113, 1, 71, 32, 35, 144, + 101, 74, 182, 72, 73, 64, 113, 1, 39, 184, 46, 64, 46, 205, 230, 133, 208, 194, 7, 92, 122, + 253, 102, 184, 225, 76, 142, 247, 228, 16, 4, 189, 132, 115, 31, 50, 149, 180, 21, 64, 153, + 200, 159, 68, 7, 189, 8, 172, 186, 214, 174, 159, 214, 245, 9, 232, 210, 53, 21, 47, 145, + 62, 108, 20, 49, 25, 138, 94, 89, 252, 93, 93, 85, 67, 3, 217, 48, 98, 211, 86, 188, 193, + 8, 215, 6, 26, 39, 151, 108, 211, 238, 56, 135, 89, 102, 241, 33, 101, 194, 141, 170, 46, + 123, 126, 84, 140, 48, 157, 68, 57, 136, 165, 51, 69, 89, 212, 167, 166, 220, 26, 66, 237, + 190, 118, 175, 108, 113, 212, 140, 217, 141, 118, 166, 93, 135, 182, 135, 66, 32, 112, 216, + 88, 106, 160, 228, 120, 112, 219, 29, 160, 220, 170, 105, 91, 171, 79, 65, 191, 149, 172, + 205, 167, 184, 137, 212, 90, 189, 200, 151, 200, 166, 70, 123, 12, 188, 112, 97, 123, 249, + 99, 93, 111, 83, 66, 46, 154, 129, 150, 16, 39, 214, 111, 226, 72, 211, 94, 1, 31, 207, + 234, 160, 200, 229, 215, 195, 178, 225, 41, 83, 248, 43, 82, 130, 192, 226, 247, 88, 97, + 170, 52, 164, 129, 85, 1, 95, 23, 96, 76, 22, 192, 1, 229, 179, 101, 32, 198, 223, 97, 30, + 172, 51, 95, 222, 138, 226, 61, 144, 159, 2, 227, 29, 97, 170, 59, 133, 24, 42, 253, 237, + 69, 220, 91, 110, 142, 250, 230, 235, 224, 205, 164, 9, 170, 111, 136, 155, 188, 251, 142, + 215, 226, 211, 243, 214, 214, 114, 35, 115, 4, 190, 117, 0, 60, 92, 13, 118, 119, 3, 159, + 129, 220, 183, 88, 228, 208, 156, 55, 127, 15, 167, 144, 224, 245, 40, 190, 230, 109, 225, + 84, 180, 116, 221, 250, 3, 132, 206, 22, 108, 159, 196, 29, 134, 6, 23, 67, 32, 254, 50, + 244, 196, 184, 30, 23, 254, 32, 19, 187, 31, 123, 225, 219, 64, 204, 126, 191, 78, 6, 146, + 234, 27, 210, 114, 8, 232, 147, 7, 103, 92, 79, 141, 155, 158, 51, 43, 3, 139, 43, 9, 158, + 200, 83, 195, 114, 93, 231, 35, 5, 38, 75, 107, 203, 211, 218, 30, 119, 188, 119, 98, 226, + 160, 194, 167, 127, 164, 57, 142, 47, 92, 4, 48, 16, 112, 155, 52, 226, 11, 85, 239, 169, + 194, 249, 98, 226, 116, 134, 203, 101, 235, 36, 96, 182, 45, 48, 156, 1, 66, 8, 108, 220, + 204, 205, 229, 195, 254, 69, 111, 115, 217, 198, 199, 215, 226, 247, 147, 114, 10, 86, 132, + 57, 110, 133, 23, 80, 60, 163, 47, 167, 58, 5, 201, 202, 197, 212, 216, 44, 111, 187, 103, + 45, 247, 33, 78, 166, 57, 21, 163, 251, 66, 209, 199, 44, 21, 110, 74, 29, 150, 253, 139, + 218, 213, 118, 246, 67, 62, 90, 3, 75, 33, 102, 241, 133, 249, 237, 192, 47, 142, 125, 169, + 19, 14, 112, 107, 93, 77, 40, 25, 19, 119, 252, 142, 19, 22, 6, 163, 42, 18, 94, 157, 0, + 189, 237, 177, 157, 82, 164, 177, 145, 205, 38, 236, 93, 49, 60, 51, 25, 20, 206, 27, 209, + 205, 1, 95, 199, 236, 122, 124, 170, 150, 100, 189, 39, 127, 44, 32, 200, 55, 42, 111, 145, + 205, 189, 127, 172, 217, 132, 128, 146, 115, 137, 237, 179, 205, 188, 120, 115, 171, 104, + 254, 86, 11, 45, 133, 148, 231, 102, 42, 108, 110, 90, 235, 119, 49, 192, 164, 233, 171, + 117, 47, 12, 28, 234, 183, 162, 237, 114, 155, 67, 150, 235, 69, 23, 187, 52, 159, 73, 173, + 94, 118, 232, 8, 158, 16, 88, 128, 45, 26, 253, 249, 194, 178, 101, 34, 226, 134, 18, 230, + 3, 146, 107, 166, 42, 238, 245, 204, 148, 146, 230, 221, 121, 125, 119, 233, 120, 105, 65, + 34, 40, 30, 248, 121, 156, 45, 97, 104, 100, 149, 79, 47, 43, 213, 143, 246, 239, 173, 32, + 197, 241, 100, 210, 51, 220, 154, 90, 69, 119, 215, 179, 169, 160, 79, 147, 173, 212, 151, + 244, 56, 152, 97, 38, 30, 38, 25, 226, 69, 37, 37, 198, 136, 220, 161, 28, 57, 27, 120, + 247, 6, 19, 157, 210, 82, 217, 158, 237, 152, 226, 65, 225, 76, 117, 31, 60, 9, 86, 24, + 248, 253, 146, 108, 15, 94, 13, 8, 49, 3, 34, 40, 197, 210, 121, 62, 19, 4, 30, 44, 35, + 102, 146, 151, 248, 58, 130, 4, 83, 18, 84, 132, 37, 160, 121, 0, 52, 185, 195, 27, 218, + 132, 234, 84, 103, 62, 40, 13, 84, 94, 115, 185, 128, 15, 166, 74, 27, 49, 119, 182, 159, + 141, 188, 248, 174, 176, 215, 193, 37, 98, 186, 239, 231, 181, 63, 237, 66, 154, 148, 73, + 183, 32, 32, 240, 202, 65, 174, 82, 86, 115, 160, 208, 173, 68, 247, 30, 129, 149, 74, 53, + 171, 25, 72, 157, 121, 253, 44, 242, 129, 4, 129, 97, 179, 6, 160, 43, 81, 248, 38, 98, 15, + 75, 128, 10, 181, 30, 40, 61, 112, 93, 66, 187, 207, 35, 115, 232, 46, 204, 29, 4, 253, 62, + 143, 153, 126, 166, 251, 34, 47, 106, 39, 242, 117, 146, 249, 79, 19, 217, 222, 37, 112, + 251, 156, 81, 145, 127, 228, 176, 157, 127, 99, 168, 138, 1, 24, 242, 113, 52, 46, 42, 132, + 100, 100, 191, 21, 237, 240, 4, 87, 139, 8, 76, 36, 113, 112, 97, 68, 142, 163, 41, 75, + 169, 2, 204, 74, 187, 184, 252, 235, 151, 48, 122, 92, 203, 61, 223, 253, 28, 226, 199, 1, + 142, 112, 76, 232, 92, 201, 62, 101, 39, 213, 183, 188, 247, 83, 207, 113, 181, 194, 33, + 255, 246, 247, 244, 217, 55, 84, 231, 125, 56, 89, 91, 242, 21, 59, 119, 171, 108, 123, 41, + 213, 92, 53, 75, 177, 74, 68, 5, 199, 76, 124, 22, 73, 175, 216, 154, 125, 180, 39, 230, + 17, 27, 242, 36, 247, 77, 221, 19, 30, 99, 111, 212, 194, 236, 3, 243, 152, 42, 153, 32, + 173, 39, 45, 220, 161, 164, 92, 185, 21, 142, 238, 116, 67, 202, 250, 72, 223, 252, 30, 7, + 138, 34, 234, 36, 255, 254, 191, 156, 107, 72, 193, 58, 30, 153, 53, 181, 213, 255, 107, + 150, 19, 253, 52, 238, 202, 115, 100, 151, 8, 140, 73, 185, 19, 74, 80, 85, 164, 8, 159, + 219, 79, 93, 29, 55, 106, 247, 136, 80, 249, 248, 76, 112, 184, 53, 136, 147, 229, 179, + 139, 191, 66, 189, 24, 199, 191, 3, 36, 229, 251, 21, 11, 137, 117, 170, 249, 29, 58, 186, + 65, 185, 30, 107, 153, 182, 24, 186, 15, 74, 100, 244, 88, 97, 246, 160, 154, 67, 236, 10, + 20, 200, 216, 104, 46, 92, 82, 164, 49, 186, 197, 249, 83, 28, 164, 99, 141, 17, 191, 62, + 84, 237, 24, 143, 162, 83, 19, 161, 57, 210, 104, 127, 147, 146, 14, 117, 231, 228, 39, 22, + 51, 47, 177, 191, 150, 219, 27, 54, 10, 21, 170, 10, 238, 255, 238, 44, 167, 184, 174, 49, + 0, 131, 143, 106, 38, 243, 248, 10, 199, 96, 132, 74, 96, 66, 181, 220, 136, 119, 145, 80, + 95, 85, 30, 103, 8, 14, 166, 238, 250, 137, 87, 41, 115, 118, 102, 161, 31, 16, 104, 222, + 213, 135, 194, 29, 105, 242, 96, 201, 183, 79, 58, 213, 80, 165, 212, 18, 173, 217, 29, + 198, 219, 214, 15, 235, 164, 227, 154, 120, 88, 152, 116, 90, 237, 229, 79, 82, 73, 73, + 238, 38, 130, 235, 200, 48, 97, 61, 130, 29, 173, 142, 243, 249, 100, 75, 126, 203, 188, + 34, 241, 99, 156, 247, 79, 19, 24, 5, 93, 45, 253, 211, 155, 243, 57, 140, 162, 103, 132, + 59, 77, 153, 210, 73, 68, 34, 195, 174, 151, 201, 156, 165, 120, 87, 137, 56, 110, 197, + 138, 71, 224, 216, 28, 70, 158, 30, 63, 134, 104, 245, 226, 172, 152, 42, 31, 198, 9, 233, + 42, 222, 124, 119, 21, 148, 32, 38, 245, 15, 57, 39, 48, 39, 207, 73, 171, 251, 98, 192, + 143, 44, 124, 238, 154, 105, 186, 39, 82, 159, 155, 233, 144, 39, 14, 188, 195, 199, 76, + 177, 2, 105, 193, 142, 106, 204, 120, 21, 143, 177, 34, 233, 131, 199, 183, 94, 2, 180, 3, + 164, 175, 43, 14, 200, 91, 45, 196, 17, 182, 205, 98, 173, 148, 218, 252, 88, 201, 78, 117, + 149, 80, 140, 199, 91, 255, 201, 26, 37, 95, 14, 100, 253, 18, 4, 219, 75, 129, 67, 51, + 186, 118, 31, 238, 242, 52, 113, 238, 209, 223, 81, 129, 36, 82, 131, 40, 92, 152, 80, 46, + 101, 152, 115, 228, 248, 241, 167, 125, 191, 245, 244, 124, 125, 68, 177, 118, 240, 158, + 212, 155, 97, 65, 238, 134, 95, 108, 33, 106, 200, 115, 7, 142, 71, 16, 186, 146, 75, 190, + 160, 1, 100, 173, 34, 189, 140, 169, 20, 12, 181, 255, 74, 48, 1, 104, 117, 132, 204, 71, + 65, 202, 41, 99, 160, 83, 103, 66, 56, 227, 116, 189, 184, 218, 152, 199, 238, 93, 245, + 147, 113, 150, 138, 237, 142, 9, 226, 216, 53, 31, 119, 188, 220, 169, 131, 214, 105, 234, + 135, 209, 45, 160, 229, 97, 93, 196, 192, 107, 185, 10, 112, 140, 207, 126, 64, 226, 205, + 167, 156, 239, 155, 96, 221, 28, 115, 91, 19, 208, 111, 50, 13, 176, 65, 52, 204, 105, 67, + 104, 52, 191, 211, 7, 154, 214, 143, 99, 127, 254, 130, 149, 209, 176, 72, 192, 202, 233, + 243, 14, 15, 194, 248, 95, 249, 8, 55, 21, 184, 241, 176, 66, 86, 108, 187, 249, 11, 168, + 121, 107, 167, 144, 72, 238, 29, 102, 50, 10, 36, 4, 24, 56, 140, 110, 45, 154, 7, 220, + 168, 248, 111, 254, 139, 247, 56, 174, 132, 53, 173, 222, 102, 219, 173, 167, 220, 198, + 229, 226, 79, 246, 140, 54, 81, 144, 153, 21, 138, 149, 214, 6, 64, 174, 72, 177, 113, 217, + 42, 3, 72, 238, 191, 177, 67, 238, 185, 129, 62, 93, 195, 118, 229, 110, 54, 168, 127, 247, + 23, 9, 198, 87, 35, 160, 2, 62, 10, 54, 150, 165, 181, 201, 19, 194, 24, 184, 59, 121, 95, + 226, 98, 113, 188, 210, 146, 39, 83, 253, 226, 10, 27, 218, 43, 38, 223, 124, 136, 36, 7, + 253, 181, 138, 104, 2, 249, 51, 229, 247, 19, 244, 212, 15, 122, 109, 83, 11, 120, 218, + 165, 36, 161, 60, 249, 148, 184, 43, 126, 184, 37, 188, 131, 13, 189, 39, 2, 73, 195, 63, + 232, 59, 200, 76, 82, 191, 241, 128, 235, 126, 187, 135, 172, 249, 198, 91, 73, 255, 117, + 61, 111, 241, 46, 25, 11, 58, 241, 128, 27, 34, 100, 247, 235, 242, 56, 50, 90, 130, 192, + 117, 189, 39, 157, 105, 176, 232, 153, 190, 91, 185, 153, 98, 173, 43, 112, 91, 82, 65, + 104, 200, 9, 103, 6, 29, 231, 145, 243, 82, 94, 247, 245, 220, 133, 29, 106, 10, 70, 53, + 176, 18, 190, 167, 252, 240, 58, 217, 234, 44, 105, 198, 121, 111, 90, 33, 125, 224, 91, + 211, 65, 183, 126, 126, 58, 116, 73, 40, 186, 253, 158, 229, 242, 58, 24, 180, 166, 52, + 133, 135, 142, 172, 25, 88, 45, 180, 177, 154, 80, 8, 95, 169, 58, 170, 130, 160, 142, 6, + 9, 11, 161, 233, 73, 175, 59, 253, 4, 52, 105, 167, 169, 79, 55, 135, 87, 48, 16, 175, 170, + 70, 175, 194, 95, 141, 95, 249, 118, 254, 169, 98, 39, 157, 245, 101, 243, 71, 31, 101, + 217, 209, 33, 119, 182, 66, 192, 216, 136, 76, 107, 221, 202, 107, 30, 126, 121, 1, 82, + 159, 54, 9, 12, 254, 107, 163, 221, 238, 223, 146, 204, 248, 220, 173, 141, 83, 253, 116, + 158, 41, 25, 14, 67, 66, 14, 159, 164, 105, 240, 137, 170, 254, 131, 159, 182, 190, 63, + 208, 238, 12, 40, 113, 185, 119, 24, 183, 40, 8, 10, 81, 3, 34, 120, 164, 191, 20, 14, 90, + 97, 121, 133, 187, 208, 64, 9, 33, 203, 41, 174, 152, 190, 82, 238, 235, 136, 126, 190, 92, + 118, 120, 132, 194, 63, 214, 54, 11, 94, 156, 233, 219, 124, 123, 234, 3, 233, 189, 181, + 103, 92, 88, 93, 52, 215, 0, 193, 103, 149, 64, 15, 187, 135, 24, 30, 179, 170, 155, 172, + 67, 135, 151, 203, 211, 165, 48, 136, 195, 214, 80, 76, 65, 156, 156, 23, 152, 93, 155, + 160, 208, 50, 189, 173, 226, 202, 131, 156, 138, 203, 248, 65, 153, 251, 183, 242, 151, 63, + 129, 232, 24, 104, 241, 139, 89, 203, 131, 229, 12, 80, 255, 133, 67, 87, 184, 38, 214, + 181, 9, 119, 159, 20, 94, 80, 166, 39, 154, 106, 9, 137, 110, 59, 139, 149, 99, 140, 253, + 183, 234, 102, 110, 27, 202, 98, 221, 56, 19, 115, 179, 231, 127, 37, 135, 16, 65, 136, 34, + 11, 110, 129, 212, 106, 186, 53, 38, 200, 209, 174, 111, 30, 209, 42, 36, 169, 96, 102, 69, + 13, 84, 160, 117, 233, 212, 15, 203, 220, 48, 91, 67, 101, 8, 57, 243, 156, 3, 181, 185, + 252, 204, 180, 20, 252, 60, 16, 168, 87, 184, 6, 251, 124, 101, 59, 152, 252, 37, 132, 161, + 173, 238, 55, 210, 113, 10, 163, 1, 173, 95, 129, 80, 61, 109, 219, 91, 243, 116, 83, 135, + 158, 234, 167, 59, 72, 87, 21, 196, 246, 231, 142, 174, 232, 247, 85, 9, 201, 242, 228, + 164, 70, 174, 192, 130, 90, 78, 61, 79, 53, 146, 56, 55, 28, 160, 134, 143, 174, 168, 139, + 59, 1, 15, 17, 156, 236, 152, 52, 205, 46, 250, 187, 113, 8, 158, 146, 233, 187, 70, 198, + 20, 217, 15, 185, 59, 46, 28, 197, 65, 50, 41, 39, 123, 83, 37, 221, 17, 226, 127, 250, + 232, 87, 70, 225, 65, 154, 78, 99, 101, 75, 113, 51, 124, 85, 155, 120, 227, 125, 254, 61, + 100, 57, 188, 178, 50, 68, 67, 156, 90, 236, 198, 177, 61, 91, 120, 129, 8, 107, 125, 103, + 219, 172, 173, 171, 109, 68, 219, 242, 149, 127, 1, 212, 188, 152, 32, 100, 98, 17, 197, + 161, 197, 253, 199, 113, 228, 33, 189, 120, 209, 77, 66, 95, 157, 82, 241, 2, 110, 3, 38, + 77, 159, 85, 75, 120, 150, 173, 94, 159, 253, 1, 253, 222, 96, 178, 52, 180, 238, 233, 105, + 15, 50, 176, 233, 210, 181, 55, 206, 243, 119, 212, 64, 168, 248, 241, 7, 195, 156, 9, 85, + 192, 2, 221, 153, 157, 150, 132, 91, 217, 162, 33, 206, 143, 161, 185, 144, 146, 150, 225, + 110, 227, 119, 144, 134, 97, 13, 161, 175, 144, 133, 97, 5, 107, 102, 69, 53, 218, 110, + 183, 182, 11, 236, 90, 179, 52, 171, 154, 170, 156, 121, 89, 217, 104, 214, 126, 46, 148, + 57, 150, 47, 29, 117, 212, 177, 229, 116, 123, 240, 206, 249, 54, 159, 54, 143, 92, 72, + 143, 0, 155, 184, 202, 71, 13, 14, 50, 121, 151, 246, 126, 250, 92, 5, 5, 85, 20, 142, 218, + 7, 202, 78, 205, 195, 102, 31, 23, 4, 101, 175, 48, 164, 33, 39, 19, 84, 115, 126, 138, + 146, 195, 98, 13, 159, 43, 135, 97, 172, 206, 44, 201, 74, 98, 8, 144, 214, 29, 3, 101, 98, + 24, 116, 229, 163, 152, 68, 251, 26, 243, 68, 133, 131, 234, 222, 20, 247, 118, 105, 252, + 20, 140, 131, 224, 159, 18, 177, 44, 184, 172, 169, 225, 3, 80, 226, 93, 159, 173, 8, 140, + 202, 128, 122, 96, 212, 73, 56, 125, 72, 43, 40, 242, 182, 205, 98, 27, 177, 222, 140, 254, + 253, 147, 61, 248, 28, 74, 250, 4, 35, 132, 194, 67, 53, 45, 216, 54, 87, 240, 103, 209, + 152, 205, 32, 235, 120, 153, 151, 144, 196, 122, 245, 222, 221, 37, 180, 181, 141, 83, 178, + 100, 55, 27, 43, 50, 226, 18, 177, 158, 47, 186, 170, 19, 237, 57, 151, 29, 73, 28, 36, + 144, 92, 243, 252, 143, 179, 153, 65, 179, 96, 33, 209, 29, 75, 115, 93, 223, 46, 123, 61, + 14, 13, 82, 132, 90, 161, 241, 12, 3, 95, 218, 233, 77, 87, 119, 153, 17, 207, 113, 126, + 233, 70, 185, 200, 82, 17, 230, 135, 242, 64, 201, 148, 70, 29, 43, 154, 129, 169, 140, + 201, 7, 238, 200, 87, 159, 123, 202, 83, 28, 85, 174, 184, 151, 14, 216, 195, 18, 150, 131, + 97, 87, 180, 199, 76, 248, 120, 137, 214, 142, 150, 99, 174, 110, 178, 45, 57, 215, 31, + 158, 180, 99, 163, 1, 149, 152, 79, 137, 199, 64, 165, 120, 61, 71, 94, 89, 138, 145, 125, + 167, 77, 159, 125, 110, 10, 70, 64, 156, 69, 145, 11, 180, 38, 24, 140, 75, 162, 13, 78, + 151, 104, 127, 243, 132, 136, 92, 194, 116, 173, 20, 147, 17, 47, 206, 208, 217, 184, 73, + 123, 213, 113, 5, 91, 115, 120, 175, 222, 157, 173, 83, 217, 116, 195, 12, 111, 128, 146, + 111, 165, 246, 10, 126, 186, 190, 146, 176, 198, 97, 159, 160, 133, 25, 242, 152, 220, 238, + 109, 97, 41, 160, 31, 41, 2, 32, 190, 32, 253, 219, 85, 148, 1, 190, 229, 142, 28, 210, + 142, 212, 60, 45, 12, 231, 88, 221, 99, 192, 250, 208, 248, 101, 193, 192, 140, 25, 37, + 122, 95, 181, 36, 91, 168, 75, 112, 41, 140, 169, 1, 66, 165, 59, 30, 253, 10, 23, 244, 96, + 29, 66, 111, 110, 73, 232, 177, 136, 230, 89, 18, 117, 85, 253, 87, 168, 102, 82, 69, 107, + 66, 23, 30, 249, 100, 28, 65, 210, 161, 39, 150, 74, 36, 141, 27, 176, 136, 242, 197, 245, + 205, 238, 248, 236, 158, 1, 34, 155, 80, 148, 110, 93, 134, 202, 30, 63, 201, 156, 3, 113, + 62, 52, 93, 204, 223, 199, 12, 13, 176, 218, 164, 73, 8, 46, 141, 52, 114, 154, 225, 69, + 218, 128, 255, 32, 52, 72, 249, 125, 231, 198, 246, 13, 247, 169, 50, 34, 186, 243, 230, + 118, 160, 178, 191, 117, 201, 237, 31, 22, 8, 157, 204, 77, 108, 122, 162, 145, 241, 16, + 35, 85, 202, 128, 176, 16, 67, 169, 177, 174, 9, 86, 99, 213, 22, 139, 241, 85, 41, 204, + 134, 113, 111, 90, 230, 49, 7, 103, 93, 15, 229, 39, 26, 136, 121, 214, 112, 243, 111, 61, + 176, 59, 46, 135, 92, 142, 198, 245, 41, 1, 181, 45, 253, 103, 226, 43, 144, 132, 111, 202, + 17, 32, 61, 177, 188, 21, 112, 74, 180, 2, 212, 200, 183, 17, 181, 12, 104, 34, 41, 177, + 109, 23, 128, 40, 14, 217, 106, 35, 33, 170, 55, 2, 247, 123, 161, 95, 47, 13, 111, 70, + 248, 118, 216, 143, 131, 153, 91, 196, 26, 204, 132, 221, 129, 169, 198, 157, 165, 19, 54, + 86, 76, 63, 187, 153, 178, 118, 152, 120, 176, 83, 42, 64, 58, 151, 48, 95, 40, 33, 18, + 137, 50, 33, 146, 99, 102, 246, 223, 79, 197, 59, 66, 238, 245, 152, 188, 47, 211, 242, + 247, 197, 203, 55, 213, 44, 220, 178, 108, 198, 163, 113, 102, 131, 154, 26, 98, 216, 144, + 52, 16, 221, + ]; + let expected_pk_bytes = [ + 69, 67, 166, 252, 181, 30, 219, 187, 255, 212, 125, 14, 181, 190, 91, 141, 76, 44, 163, + 248, 133, 22, 62, 168, 194, 114, 50, 223, 158, 28, 15, 151, 210, 30, 86, 176, 192, 160, 72, + 23, 220, 65, 128, 40, 103, 124, 96, 139, 146, 169, 245, 25, 138, 61, 2, 171, 121, 29, 66, + 129, 142, 109, 197, 122, 93, 26, 82, 43, 156, 60, 45, 170, 100, 56, 64, 67, 39, 157, 202, + 28, 20, 57, 135, 125, 104, 21, 207, 130, 140, 173, 16, 32, 122, 30, 76, 172, 91, 181, 191, + 90, 133, 94, 26, 127, 2, 102, 214, 29, 87, 186, 120, 111, 190, 123, 173, 120, 89, 214, 73, + 70, 222, 205, 157, 100, 194, 39, 197, 129, 165, 196, 190, 130, 165, 108, 42, 18, 190, 151, + 212, 79, 178, 9, 92, 54, 13, 14, 145, 57, 196, 224, 12, 117, 44, 46, 11, 100, 36, 215, 31, + 218, 249, 209, 53, 206, 238, 238, 102, 57, 62, 209, 62, 184, 15, 118, 35, 93, 74, 188, 52, + 22, 107, 137, 116, 191, 209, 99, 194, 211, 165, 113, 94, 222, 153, 72, 150, 89, 1, 88, 153, + 176, 240, 225, 76, 175, 89, 29, 225, 22, 223, 87, 238, 36, 53, 38, 227, 172, 59, 185, 113, + 138, 55, 10, 246, 33, 17, 190, 204, 19, 100, 117, 134, 1, 69, 175, 70, 139, 10, 70, 236, + 22, 249, 24, 191, 226, 20, 87, 101, 101, 245, 204, 27, 119, 97, 9, 42, 221, 90, 104, 227, + 116, 172, 167, 147, 111, 242, 0, 193, 224, 3, 49, 186, 28, 161, 214, 150, 219, 68, 108, 24, + 61, 219, 48, 157, 249, 81, 181, 246, 15, 32, 142, 144, 164, 10, 14, 34, 37, 16, 156, 172, + 221, 70, 110, 209, 49, 74, 18, 78, 219, 32, 129, 98, 17, 77, 129, 216, 43, 107, 83, 108, + 73, 244, 156, 226, 208, 183, 22, 32, 30, 50, 56, 122, 213, 0, 176, 252, 255, 98, 234, 155, + 65, 78, 153, 37, 200, 143, 19, 226, 156, 180, 26, 147, 180, 129, 234, 185, 198, 14, 168, + 73, 230, 1, 244, 230, 164, 158, 113, 194, 249, 106, 146, 196, 38, 90, 73, 159, 200, 78, + 197, 188, 182, 27, 191, 42, 217, 220, 58, 140, 39, 113, 89, 198, 181, 241, 150, 126, 117, + 9, 205, 174, 85, 29, 18, 211, 129, 130, 169, 17, 19, 32, 154, 118, 98, 2, 51, 227, 228, + 141, 237, 179, 185, 197, 171, 117, 75, 86, 231, 16, 16, 83, 10, 23, 220, 48, 151, 115, 173, + 143, 134, 149, 53, 205, 2, 181, 109, 26, 70, 92, 196, 24, 226, 242, 53, 189, 113, 195, 222, + 151, 236, 99, 53, 251, 153, 121, 121, 190, 69, 9, 134, 150, 223, 21, 223, 30, 73, 111, 45, + 21, 182, 109, 211, 42, 147, 183, 250, 37, 122, 38, 183, 12, 106, 16, 172, 136, 97, 86, 77, + 203, 191, 225, 55, 56, 172, 251, 35, 235, 223, 158, 110, 121, 22, 91, 202, 148, 88, 40, + 122, 24, 63, 135, 144, 193, 10, 199, 5, 236, 240, 85, 136, 47, 27, 93, 173, 219, 187, 148, + 231, 163, 93, 205, 25, 76, 174, 39, 128, 159, 62, 164, 238, 140, 193, 5, 33, 202, 169, 255, + 155, 136, 7, 130, 71, 185, 139, 252, 101, 243, 138, 86, 191, 92, 71, 139, 197, 41, 86, 74, + 148, 20, 225, 45, 225, 51, 196, 167, 65, 179, 91, 228, 200, 109, 184, 168, 17, 14, 181, + 186, 162, 75, 110, 154, 2, 141, 230, 191, 83, 231, 160, 94, 244, 6, 1, 78, 39, 59, 193, 99, + 119, 151, 157, 223, 89, 55, 171, 232, 78, 79, 92, 189, 59, 185, 63, 31, 87, 126, 56, 18, + 54, 25, 35, 143, 27, 81, 60, 87, 239, 10, 139, 147, 190, 249, 123, 210, 38, 69, 83, 76, 4, + 228, 143, 199, 244, 185, 156, 46, 136, 188, 5, 139, 132, 234, 19, 161, 135, 92, 16, 209, + 123, 114, 34, 71, 107, 159, 10, 10, 45, 19, 210, 248, 244, 198, 164, 150, 156, 73, 114, + 219, 229, 179, 254, 242, 91, 214, 200, 157, 90, 3, 19, 249, 41, 199, 19, 107, 62, 118, 6, + 248, 162, 85, 35, 169, 180, 219, 19, 204, 251, 175, 236, 16, 38, 98, 94, 144, 213, 19, 251, + 245, 139, 234, 194, 205, 72, 118, 95, 152, 52, 66, 165, 65, 40, 48, 230, 38, 117, 154, 66, + 67, 102, 221, 247, 158, 174, 200, 56, 100, 222, 150, 250, 48, 145, 109, 190, 177, 233, 224, + 128, 117, 51, 114, 237, 167, 93, 0, 72, 223, 26, 99, 57, 170, 65, 166, 119, 156, 23, 244, + 188, 166, 31, 139, 224, 226, 105, 2, 46, 34, 40, 124, 234, 250, 171, 114, 59, 49, 56, 228, + 245, 216, 66, 62, 130, 71, 247, 76, 79, 148, 132, 141, 84, 179, 32, 9, 119, 246, 112, 181, + 200, 187, 227, 4, 154, 255, 179, 50, 123, 218, 230, 47, 48, 89, 201, 232, 129, 56, 9, 194, + 15, 219, 92, 136, 241, 211, 202, 243, 234, 177, 159, 176, 86, 20, 10, 159, 65, 150, 186, + 244, 130, 225, 166, 6, 236, 211, 90, 122, 223, 8, 3, 233, 203, 156, 80, 69, 216, 35, 21, + 169, 201, 30, 82, 25, 20, 95, 103, 124, 150, 207, 241, 200, 196, 151, 65, 58, 93, 13, 64, + 75, 182, 77, 90, 212, 30, 240, 195, 156, 124, 91, 158, 32, 229, 13, 175, 158, 110, 43, 89, + 161, 20, 114, 84, 151, 163, 177, 230, 90, 4, 167, 168, 83, 193, 109, 74, 30, 163, 145, 223, + 52, 133, 233, 188, 138, 190, 103, 10, 126, 251, 123, 130, 23, 245, 86, 20, 185, 119, 23, + 71, 208, 197, 234, 110, 210, 216, 141, 26, 50, 55, 227, 14, 33, 19, 198, 22, 180, 206, 92, + 23, 133, 46, 107, 82, 122, 107, 51, 243, 68, 8, 36, 179, 15, 166, 55, 95, 234, 50, 148, + 148, 65, 158, 253, 201, 13, 86, 198, 139, 10, 98, 59, 187, 112, 22, 199, 233, 114, 32, 23, + 6, 169, 116, 58, 167, 250, 120, 117, 247, 169, 239, 87, 138, 229, 13, 10, 97, 168, 185, + 145, 68, 110, 172, 1, 184, 229, 11, 18, 199, 66, 110, 194, 120, 10, 189, 26, 214, 165, 35, + 225, 203, 176, 118, 79, 150, 128, 123, 158, 68, 161, 193, 77, 93, 155, 60, 242, 79, 73, + 176, 145, 135, 75, 66, 160, 30, 124, 129, 177, 188, 121, 72, 16, 207, 141, 219, 191, 157, + 190, 100, 123, 235, 132, 250, 19, 129, 161, 37, 40, 4, 71, 25, 219, 2, 191, 50, 162, 113, + 143, 76, 121, 189, 140, 144, 81, 63, 224, 50, 144, 208, 58, 173, 122, 60, 2, 76, 167, 55, + 224, 123, 44, 221, 52, 193, 116, 227, 131, 1, 214, 89, 62, 201, 99, 228, 12, 74, 73, 190, + 8, 88, 65, 89, 156, 121, 212, 229, 148, 78, 13, 217, 116, 121, 61, 191, 224, 28, 116, 250, + 18, 30, 234, 150, 172, 7, 63, 164, 22, 136, 174, 19, 68, 142, 169, 183, 5, 34, 118, 128, + 158, 102, 210, 98, 218, 200, 84, 217, 235, 205, 57, 121, 86, 59, 149, 223, 119, 245, 179, + 69, 8, 96, 246, 137, 54, 49, 60, 101, 175, 211, 35, 52, 245, 49, 98, 251, 29, 34, 15, 44, + 118, 90, 87, 217, 131, 5, 239, 110, 180, 183, 209, 36, 65, 88, 211, 64, 167, 97, 252, 199, + 251, 6, 82, 203, 22, 84, 168, 116, 123, 71, 245, 147, 89, 81, 185, 10, 231, 78, 131, 83, + 88, 16, 181, 97, 12, 18, 42, 28, 97, 166, 155, 112, 118, 148, 182, 250, 165, 247, 144, 135, + 7, 1, 67, 57, 15, 135, 154, 29, 10, 51, 18, 227, 41, 46, 152, 112, 243, 160, 207, 147, 245, + 209, 113, 157, 202, 121, 22, 206, 150, 164, 218, 125, 135, 189, 66, 222, 95, 84, 91, 73, + 147, 60, 55, 9, 49, 142, 62, 165, 10, 141, 150, 145, 236, 223, 253, 16, 192, 146, 254, 143, + 129, 139, 190, 79, 253, 99, 41, 253, 69, 101, 162, 97, 25, 180, 26, 116, 38, 54, 57, 47, + 88, 70, 115, 95, 142, 172, 12, 53, 221, 199, 20, 26, 227, 68, 4, 124, 80, 236, 7, 147, 50, + 46, 28, 65, 91, 77, 6, 163, 195, 88, 143, 185, 177, 124, 101, 87, 44, 65, 129, 186, 105, + 160, 177, 44, 4, 32, 225, 58, 117, 114, 203, 92, 68, 50, 218, 98, 249, 244, 246, 248, 224, + 55, 84, 38, 112, 131, 92, 196, 219, 114, 74, 155, 217, 142, 131, 192, 38, 102, 88, 93, 17, + 179, 174, 176, 168, 43, 176, 223, 17, 82, 18, 130, 35, 90, 107, 213, 189, 174, 220, 193, + 241, 251, 248, 123, 253, 202, 195, 56, 145, 220, 213, 46, 24, 218, 118, 33, 104, 138, 229, + 129, 5, 125, 26, 205, 92, 216, 96, 145, 81, 49, 185, 220, 251, 98, 121, 242, 171, 228, 239, + 52, 79, 40, 28, 239, 1, 82, 72, 198, 4, 116, 149, 62, 118, 160, 100, 86, 82, 33, 206, 138, + 222, 176, 72, 202, 46, 239, 85, 77, 156, 163, 164, 76, 167, 225, 171, 106, 211, 149, 44, + 82, 125, 221, 50, 97, 16, 171, 120, 159, 140, 225, 173, 44, 199, 9, 128, 201, 233, 136, + 240, 146, 191, 22, 52, 138, 131, 91, 153, 185, 149, 71, 24, 23, 77, 22, 177, 163, 171, 37, + 135, 146, 60, 109, 255, 241, 101, 186, 32, 234, 68, 252, 199, 203, 71, 227, 214, 33, 26, + 81, 83, 25, 204, 42, 83, 251, 217, 1, 59, 32, 89, 243, 98, 12, 77, 180, 56, 251, 159, 158, + 24, 167, 214, 9, 225, 55, 238, 130, 91, 135, 89, 21, 128, 230, 212, 117, 190, 228, 77, 61, + 9, 175, 236, 71, 205, 113, 194, 10, 154, 233, 141, 5, 31, 48, 90, 70, 68, 15, 234, 207, 48, + 245, 247, 107, 96, 77, 255, 53, 39, 42, 169, 138, 134, 111, 121, 235, 45, 108, 101, 143, + 128, 17, 49, 172, 241, 12, 116, 124, 151, 20, 71, 87, 105, 202, 209, 93, 163, 54, 1, 147, + 219, 45, 16, 58, 236, 204, 174, 128, 74, 171, 123, 197, 159, 1, 80, 90, 223, 104, 67, 138, + 97, 34, 136, 112, 17, 217, 82, 133, 225, 182, 12, 67, 114, 122, 139, 222, 93, 195, 71, 216, + 70, 41, 232, 237, 103, 254, 104, 38, 235, 15, 220, 162, 13, 19, 53, 100, 29, 215, 37, 182, + 158, 14, 76, 125, 46, 170, 225, 250, 89, 107, 17, 71, 144, 135, 161, 204, 138, 197, 62, 76, + 195, 0, 222, 145, 229, 64, 135, 91, 219, 83, 188, 101, 62, 141, 10, 57, 248, 59, 13, 111, + 64, 104, 81, 171, 34, 113, 196, 61, 169, 151, 159, 124, 37, 248, 163, 137, 125, 159, 25, 6, + 72, 143, 220, 195, 202, 190, 101, 46, 150, 8, 202, 178, 211, 62, 199, 51, 107, 241, 144, + 225, 72, 58, 98, 64, 45, 180, 16, 19, 71, 109, 140, 151, 45, 193, 111, 18, 186, 10, 49, + 185, 223, 28, 91, 4, 164, 210, 206, 65, 250, 6, 70, 162, 77, 91, 16, 148, 28, 147, 250, + 177, 254, 33, 250, 218, 32, 192, 19, 225, 209, 35, 83, 117, 205, 124, 72, 49, 16, 171, 231, + 215, 85, 18, 71, 48, 229, 248, 54, 168, 27, 243, 50, 30, 61, 242, 14, 101, 35, 195, 249, + 71, 165, 53, 80, 255, 65, 31, 251, 255, 15, 170, 48, 14, 29, 62, 38, 131, 185, 148, 62, + 191, 1, 10, 118, 16, 236, 205, 206, 253, 138, 182, 244, 144, 183, 82, 219, 189, 144, 28, + 131, 149, 225, 198, 129, 192, 18, 215, 212, 53, 90, 219, 113, 38, 226, 149, 250, 60, 126, + 99, 138, 31, 61, 181, 224, 153, 215, 233, 219, 81, 221, 247, 241, 134, 25, 92, 197, 79, 39, + 62, 71, 245, 159, 86, 161, 105, 251, 92, 70, 92, 57, 202, 104, 153, 16, 43, 119, 66, 243, + 56, 226, 232, 153, 211, 242, 124, 224, 63, 189, 107, 16, 132, 3, 8, 102, 164, 118, 29, 246, + 199, 177, 5, 90, 224, 235, 50, 238, 247, 80, 52, 144, 68, 108, 15, 135, 230, 71, 211, 238, + 251, 12, 72, 218, 204, 90, 178, 52, 196, 40, 217, 219, 8, 253, 1, 135, 202, 250, 250, 224, + 252, 200, 96, 47, 212, 73, 134, 137, 48, 250, 31, 199, 73, 220, 1, 226, 190, 40, 9, 39, + 180, 200, 165, 56, 234, 238, 216, 190, 136, 215, 36, 132, 214, 128, 61, 101, 41, 92, 230, + 227, 127, 13, 123, 67, 61, 207, 7, 206, 44, 162, 221, 116, 151, 85, 91, 198, 105, 225, 208, + 128, 62, 163, 82, 70, 152, 252, 24, 214, 136, 158, 119, 120, 166, 196, 173, 30, 219, 6, + 186, 23, 1, 39, 220, 223, 147, 102, 78, 196, 111, 231, 116, 113, 43, 19, 120, 27, 64, 184, + 161, 248, 199, 82, 162, 209, 129, 6, 146, 56, 184, 147, 243, 166, 162, 34, 161, 29, 148, + 228, 91, 107, 147, 39, 77, 157, 67, 239, 88, 28, 121, 193, 90, 3, 14, 35, 230, 124, 211, + 110, 16, 117, 26, 228, 135, 130, 199, 173, 68, 49, 175, 187, 33, 182, 48, 244, 152, 11, 92, + 189, 61, 170, 172, 99, 155, 252, 158, 69, 19, 22, 197, 150, 54, 232, 199, 142, 90, 68, 245, + 175, 166, 102, 56, 57, 4, 33, 198, 139, 108, 111, 186, 91, 13, 60, 16, 220, 127, 16, 124, + 250, 151, 1, 63, 160, 74, 217, 81, 45, 24, 52, 118, 39, 211, 202, 195, 206, 1, 233, 157, + 215, 230, 126, 136, 238, 131, 190, 77, 38, 79, 238, 234, 249, 137, 74, 47, 134, 121, 216, + 167, 166, 119, 201, 5, 52, 254, 16, 147, 232, 176, 90, 6, 23, 127, 25, 58, 159, 255, 8, 11, + 151, 51, 17, 50, 104, 194, 4, 182, 120, 5, 159, 155, 195, 8, 16, 60, 80, 103, 78, 114, 60, + 170, 156, 66, 17, 43, 30, 203, 234, 96, 143, 183, 112, 56, 28, 236, 33, 225, 37, 117, 132, + 5, 254, 252, 175, 242, 45, 193, 124, 171, 133, 41, 25, 152, 196, 200, 162, 139, 50, 156, + 124, 185, 10, 98, 89, 118, 156, 177, 35, 9, 86, 222, 241, 218, 97, 90, 68, 5, 181, 34, 224, + 36, 141, 191, 116, 82, 169, 99, 67, 155, 63, 41, 169, 170, 237, 137, 174, 70, 123, 126, + 151, 159, 124, 239, 47, 157, 94, 45, 203, 40, 179, 57, 188, 209, 6, 61, 150, 205, 99, 138, + 209, 215, 168, 0, 51, 32, 224, 164, 106, 50, 19, 167, 78, 189, 103, 235, 211, 25, 60, 228, + 244, 113, 44, 184, 220, 254, 169, 230, 156, 61, 165, 101, 142, 204, 94, 132, 215, 89, 51, + 165, 89, 186, 197, 146, 231, 205, 141, 113, 194, 241, 232, 123, 214, 171, 28, 10, 223, 17, + 106, 154, 244, 159, 209, 192, 220, 23, 106, 212, 214, 77, 253, 215, 57, 236, 238, 63, 24, + 193, 87, 175, 75, 109, 227, 145, 228, 243, 248, 110, 215, 157, 42, 34, 232, 209, 19, 8, + 235, 197, 48, 59, 151, 170, 63, 80, 70, 180, 168, 212, 243, 134, 37, 11, + ]; + let expected_sig_bytes = [ + 192, 0, 120, 158, 160, 6, 242, 36, 42, 4, 80, 175, 29, 227, 6, 147, 84, 22, 223, 180, 127, + 92, 164, 105, 252, 119, 253, 104, 169, 103, 164, 188, 80, 56, 232, 174, 94, 16, 82, 95, + 168, 135, 166, 189, 173, 166, 160, 66, 50, 11, 98, 219, 198, 250, 130, 18, 45, 97, 178, + 180, 151, 215, 205, 162, 65, 217, 56, 60, 164, 175, 158, 86, 193, 136, 225, 69, 118, 183, + 238, 251, 111, 167, 128, 137, 131, 70, 92, 243, 10, 158, 217, 70, 47, 165, 254, 219, 156, + 125, 218, 29, 97, 242, 171, 92, 90, 16, 107, 122, 154, 47, 95, 184, 182, 175, 252, 226, + 177, 198, 6, 24, 220, 243, 72, 196, 235, 86, 163, 235, 73, 239, 220, 5, 144, 178, 125, 170, + 88, 26, 31, 169, 141, 81, 95, 138, 45, 7, 175, 253, 62, 135, 167, 94, 215, 164, 33, 107, + 174, 36, 249, 112, 42, 154, 164, 84, 37, 132, 229, 81, 175, 242, 82, 246, 175, 24, 143, 38, + 102, 41, 132, 183, 209, 64, 248, 178, 238, 144, 215, 212, 176, 47, 85, 165, 38, 101, 187, + 12, 10, 139, 192, 108, 208, 104, 47, 81, 229, 207, 97, 60, 7, 5, 35, 174, 40, 220, 145, + 251, 153, 199, 113, 148, 158, 32, 0, 173, 53, 190, 250, 243, 118, 128, 137, 174, 188, 53, + 177, 6, 255, 233, 189, 197, 255, 211, 207, 197, 184, 61, 161, 86, 227, 245, 208, 117, 68, + 30, 175, 73, 243, 42, 14, 17, 81, 158, 246, 62, 237, 68, 154, 74, 92, 25, 66, 96, 220, 74, + 25, 236, 133, 232, 82, 152, 71, 142, 64, 239, 49, 227, 81, 204, 82, 70, 95, 55, 255, 9, 3, + 35, 231, 47, 137, 64, 122, 211, 241, 186, 107, 195, 250, 209, 198, 22, 148, 252, 208, 37, + 158, 93, 210, 54, 92, 200, 235, 52, 90, 96, 21, 210, 51, 63, 141, 201, 223, 177, 49, 41, + 189, 107, 245, 34, 104, 18, 102, 13, 47, 76, 93, 195, 47, 111, 229, 196, 64, 163, 53, 150, + 214, 60, 139, 152, 69, 213, 23, 195, 71, 150, 110, 174, 136, 149, 69, 250, 89, 35, 3, 22, + 4, 218, 143, 26, 58, 223, 129, 27, 9, 139, 7, 12, 195, 163, 105, 30, 249, 221, 253, 59, + 193, 141, 11, 231, 252, 198, 97, 79, 106, 164, 40, 90, 193, 95, 208, 54, 103, 226, 61, 231, + 16, 36, 31, 232, 238, 126, 168, 233, 5, 238, 201, 139, 171, 115, 52, 233, 57, 165, 103, + 104, 142, 95, 237, 95, 247, 12, 137, 108, 116, 121, 9, 15, 82, 139, 83, 44, 212, 167, 158, + 32, 141, 99, 50, 5, 37, 42, 94, 51, 45, 40, 240, 102, 158, 165, 209, 101, 211, 99, 147, + 193, 117, 70, 240, 8, 122, 168, 202, 71, 141, 75, 56, 56, 239, 130, 200, 146, 18, 139, 79, + 160, 119, 118, 204, 150, 131, 69, 175, 16, 115, 203, 213, 245, 90, 1, 173, 254, 9, 169, 4, + 160, 169, 200, 13, 21, 236, 165, 205, 5, 66, 95, 73, 148, 119, 18, 212, 140, 239, 59, 180, + 5, 24, 189, 34, 151, 44, 122, 3, 151, 196, 184, 208, 168, 199, 182, 235, 234, 148, 198, 34, + 21, 118, 106, 176, 200, 72, 152, 129, 211, 183, 190, 150, 64, 243, 121, 15, 43, 199, 213, + 46, 169, 114, 27, 221, 140, 221, 185, 226, 152, 20, 219, 50, 171, 62, 217, 161, 103, 175, + 48, 84, 42, 19, 160, 5, 110, 83, 37, 1, 23, 205, 170, 180, 193, 108, 251, 47, 173, 90, 246, + 140, 122, 82, 6, 72, 19, 211, 252, 207, 61, 111, 49, 35, 30, 93, 57, 127, 22, 44, 9, 145, + 138, 239, 28, 162, 106, 138, 196, 211, 104, 171, 193, 93, 62, 204, 2, 155, 94, 47, 166, + 169, 221, 170, 131, 54, 59, 210, 84, 52, 224, 12, 100, 88, 55, 219, 139, 241, 10, 24, 111, + 200, 111, 77, 206, 120, 193, 122, 89, 135, 242, 98, 37, 227, 181, 158, 250, 162, 246, 127, + 43, 6, 117, 252, 50, 155, 75, 65, 250, 108, 83, 29, 19, 253, 230, 137, 19, 122, 13, 253, + 184, 176, 170, 92, 249, 253, 89, 161, 38, 166, 92, 118, 120, 86, 117, 83, 68, 50, 91, 219, + 158, 132, 144, 48, 211, 21, 132, 62, 165, 185, 173, 251, 173, 144, 183, 97, 245, 14, 61, + 98, 227, 244, 139, 232, 250, 123, 60, 44, 93, 31, 74, 66, 16, 106, 245, 71, 113, 84, 14, + 60, 109, 86, 42, 113, 103, 164, 110, 23, 62, 245, 222, 223, 86, 136, 69, 0, 95, 90, 35, + 221, 111, 31, 142, 254, 23, 139, 139, 112, 70, 148, 154, 203, 243, 235, 242, 120, 38, 60, + 219, 201, 129, 145, 197, 245, 238, 158, 165, 53, 109, 203, 39, 12, 175, 28, 192, 218, 249, + 160, 153, 140, 162, 45, 188, 161, 246, 72, 224, 133, 29, 222, 221, 248, 252, 148, 154, 34, + 124, 237, 188, 34, 157, 12, 182, 201, 173, 73, 179, 217, 97, 191, 55, 172, 61, 17, 98, 227, + 65, 156, 107, 120, 134, 134, 107, 179, 139, 230, 68, 59, 146, 204, 127, 67, 108, 226, 128, + 229, 0, 201, 104, 136, 158, 130, 193, 193, 10, 45, 136, 204, 24, 235, 221, 59, 45, 73, 45, + 144, 214, 81, 134, 225, 164, 3, 91, 152, 215, 62, 47, 149, 49, 99, 249, 106, 226, 219, 198, + 193, 67, 153, 143, 239, 252, 149, 116, 174, 183, 164, 5, 79, 246, 124, 6, 36, 67, 232, 205, + 212, 164, 72, 103, 4, 35, 172, 235, 65, 189, 181, 5, 48, 3, 30, 28, 218, 237, 29, 102, 102, + 3, 129, 46, 55, 1, 178, 73, 25, 202, 189, 27, 149, 79, 151, 216, 143, 126, 58, 159, 139, 3, + 15, 100, 159, 147, 244, 172, 217, 2, 180, 145, 227, 139, 200, 234, 243, 71, 1, 80, 3, 8, + 232, 99, 203, 243, 80, 199, 124, 16, 71, 3, 179, 118, 174, 105, 188, 71, 150, 193, 89, 232, + 126, 200, 142, 212, 78, 44, 140, 145, 188, 179, 222, 77, 186, 25, 193, 222, 71, 225, 195, + 148, 149, 108, 148, 35, 178, 194, 93, 47, 236, 223, 184, 99, 233, 239, 63, 14, 89, 231, + 205, 60, 194, 182, 47, 249, 35, 53, 236, 66, 79, 87, 149, 137, 40, 190, 27, 12, 146, 16, + 153, 252, 253, 96, 217, 226, 128, 58, 32, 67, 79, 101, 18, 251, 25, 90, 170, 253, 115, 59, + 253, 179, 235, 18, 102, 144, 111, 21, 199, 122, 230, 100, 233, 85, 169, 17, 79, 224, 14, + 175, 222, 34, 111, 100, 153, 118, 138, 250, 36, 145, 212, 25, 197, 79, 209, 194, 166, 234, + 56, 249, 66, 115, 243, 190, 88, 240, 15, 131, 31, 15, 59, 54, 75, 205, 226, 170, 119, 28, + 38, 160, 147, 5, 19, 73, 168, 55, 196, 129, 218, 125, 157, 238, 222, 112, 30, 251, 41, 93, + 184, 5, 67, 203, 199, 234, 168, 193, 87, 118, 16, 168, 73, 48, 146, 163, 20, 4, 206, 54, + 21, 115, 178, 210, 158, 38, 237, 4, 115, 42, 189, 130, 98, 155, 178, 182, 161, 180, 185, 2, + 74, 223, 207, 24, 223, 233, 143, 90, 239, 74, 57, 22, 8, 246, 126, 178, 195, 63, 246, 123, + 64, 109, 51, 118, 207, 59, 120, 36, 176, 156, 41, 130, 89, 64, 41, 149, 216, 91, 102, 80, + 52, 78, 103, 11, 34, 15, 60, 245, 255, 131, 235, 204, 146, 232, 21, 14, 165, 42, 88, 19, + 138, 179, 126, 203, 74, 33, 244, 122, 162, 86, 5, 71, 56, 74, 229, 69, 129, 252, 47, 133, + 98, 102, 112, 232, 235, 181, 127, 130, 100, 37, 15, 23, 49, 100, 89, 176, 160, 90, 32, 112, + 90, 189, 33, 125, 222, 134, 192, 111, 195, 51, 205, 29, 216, 123, 244, 15, 135, 173, 236, + 28, 45, 155, 151, 137, 92, 251, 133, 3, 139, 147, 243, 78, 129, 120, 180, 86, 33, 46, 223, + 66, 216, 95, 182, 75, 113, 183, 32, 224, 117, 121, 38, 148, 199, 9, 207, 160, 139, 192, + 144, 219, 4, 50, 33, 225, 141, 50, 243, 126, 151, 118, 93, 29, 126, 125, 196, 180, 160, + 223, 136, 250, 82, 250, 219, 73, 82, 228, 121, 90, 93, 192, 201, 82, 2, 22, 86, 173, 91, + 109, 98, 145, 38, 191, 247, 152, 194, 189, 12, 106, 254, 36, 16, 27, 56, 2, 180, 206, 173, + 254, 252, 29, 201, 138, 255, 255, 182, 33, 118, 67, 237, 213, 6, 41, 136, 47, 72, 191, 135, + 123, 238, 203, 156, 191, 98, 97, 247, 244, 33, 155, 103, 81, 90, 91, 143, 80, 106, 129, + 209, 255, 82, 53, 151, 37, 135, 12, 163, 73, 121, 93, 82, 161, 243, 24, 55, 197, 150, 189, + 231, 35, 236, 70, 87, 16, 217, 60, 192, 86, 139, 200, 194, 27, 160, 186, 115, 18, 221, 99, + 112, 145, 113, 205, 24, 132, 51, 167, 197, 134, 125, 181, 54, 194, 65, 24, 52, 194, 231, + 228, 14, 83, 56, 144, 133, 141, 208, 125, 237, 227, 41, 164, 203, 58, 71, 34, 132, 128, + 175, 182, 115, 80, 167, 211, 161, 125, 174, 216, 149, 227, 218, 183, 247, 81, 32, 246, 93, + 38, 126, 56, 124, 208, 253, 48, 249, 216, 192, 253, 76, 21, 17, 123, 212, 217, 86, 201, + 167, 162, 137, 246, 133, 216, 28, 191, 103, 21, 63, 61, 227, 89, 142, 156, 244, 210, 111, + 251, 144, 73, 154, 130, 131, 21, 23, 123, 6, 255, 82, 244, 30, 77, 11, 163, 4, 191, 80, + 198, 51, 185, 50, 24, 205, 88, 47, 18, 69, 238, 16, 155, 45, 62, 145, 245, 2, 66, 112, 32, + 181, 28, 104, 109, 254, 171, 102, 144, 61, 179, 162, 67, 152, 13, 42, 62, 217, 120, 129, + 47, 27, 231, 73, 178, 237, 128, 217, 107, 182, 120, 145, 80, 91, 100, 44, 175, 173, 88, + 197, 186, 147, 82, 192, 66, 104, 168, 187, 188, 209, 150, 21, 1, 237, 155, 40, 37, 254, 4, + 203, 112, 24, 215, 205, 96, 186, 83, 41, 57, 54, 122, 75, 187, 242, 251, 115, 88, 87, 236, + 93, 39, 93, 172, 77, 60, 54, 205, 180, 156, 74, 114, 42, 119, 53, 255, 137, 121, 91, 225, + 150, 225, 29, 199, 203, 155, 64, 75, 25, 110, 113, 250, 167, 85, 57, 36, 153, 152, 159, + 154, 192, 1, 75, 243, 75, 225, 141, 76, 39, 66, 101, 254, 103, 125, 206, 151, 37, 90, 248, + 83, 149, 238, 202, 215, 205, 120, 235, 64, 105, 102, 181, 109, 255, 75, 19, 234, 112, 252, + 85, 6, 13, 224, 186, 42, 150, 39, 192, 98, 73, 87, 195, 62, 6, 143, 88, 108, 51, 7, 167, + 228, 132, 126, 91, 132, 107, 99, 160, 196, 48, 207, 179, 127, 190, 32, 64, 43, 218, 53, + 174, 30, 192, 55, 192, 61, 169, 171, 48, 217, 146, 111, 145, 151, 207, 119, 15, 52, 14, 81, + 56, 41, 246, 207, 167, 133, 180, 18, 44, 39, 59, 8, 67, 225, 102, 176, 207, 0, 157, 78, 52, + 139, 152, 126, 11, 1, 145, 216, 79, 159, 203, 90, 223, 167, 3, 81, 70, 174, 13, 112, 163, + 167, 211, 232, 214, 51, 116, 228, 14, 60, 75, 81, 14, 104, 100, 180, 166, 31, 73, 13, 63, + 174, 0, 70, 102, 65, 63, 237, 200, 70, 69, 133, 164, 237, 118, 62, 203, 168, 253, 173, 204, + 94, 48, 117, 170, 106, 35, 123, 139, 7, 153, 36, 98, 136, 236, 250, 128, 157, 196, 35, 115, + 250, 19, 135, 128, 152, 110, 240, 212, 159, 39, 178, 216, 81, 72, 140, 30, 190, 122, 134, + 52, 82, 221, 57, 38, 56, 6, 45, 249, 126, 78, 214, 233, 13, 235, 50, 107, 211, 68, 61, 128, + 124, 79, 42, 116, 139, 19, 148, 149, 94, 24, 80, 133, 47, 241, 17, 102, 181, 185, 19, 66, + 127, 230, 56, 208, 184, 72, 124, 92, 72, 95, 62, 162, 234, 48, 202, 15, 169, 18, 251, 137, + 129, 227, 158, 224, 73, 140, 99, 80, 31, 61, 223, 161, 43, 194, 185, 19, 6, 45, 69, 90, + 206, 145, 18, 110, 89, 75, 251, 136, 196, 180, 148, 203, 67, 54, 144, 86, 86, 51, 142, 19, + 35, 148, 146, 84, 149, 204, 31, 164, 34, 120, 35, 191, 92, 188, 79, 246, 93, 144, 119, 148, + 106, 239, 63, 57, 131, 24, 167, 13, 135, 180, 185, 45, 207, 119, 101, 170, 96, 96, 245, + 152, 153, 156, 39, 155, 173, 172, 251, 65, 47, 131, 61, 90, 61, 178, 188, 75, 204, 84, 224, + 76, 132, 42, 82, 145, 207, 166, 110, 164, 248, 153, 156, 7, 207, 21, 169, 20, 214, 137, 43, + 32, 225, 114, 144, 86, 60, 224, 172, 204, 50, 148, 219, 72, 201, 242, 73, 157, 66, 19, 26, + 209, 127, 167, 226, 211, 208, 19, 99, 179, 247, 178, 243, 103, 211, 205, 232, 71, 132, 189, + 80, 181, 116, 159, 190, 39, 158, 198, 189, 38, 39, 201, 190, 212, 24, 2, 212, 242, 93, 121, + 206, 25, 175, 204, 125, 22, 42, 104, 238, 230, 154, 224, 43, 62, 244, 68, 202, 154, 224, + 151, 84, 101, 25, 137, 205, 69, 83, 203, 2, 21, 224, 59, 76, 32, 188, 228, 18, 50, 238, 18, + 240, 190, 133, 76, 214, 167, 110, 146, 44, 89, 9, 119, 157, 80, 238, 243, 51, 139, 89, 8, + 226, 148, 239, 220, 189, 3, 23, 17, 30, 64, 236, 226, 255, 221, 128, 111, 12, 38, 165, 101, + 182, 211, 161, 60, 93, 252, 112, 16, 228, 222, 180, 203, 52, 206, 168, 113, 9, 19, 127, 85, + 209, 158, 201, 175, 233, 22, 27, 163, 194, 26, 225, 133, 114, 146, 140, 68, 166, 164, 150, + 116, 18, 84, 240, 161, 117, 6, 68, 166, 59, 194, 199, 83, 39, 97, 170, 85, 48, 45, 102, + 210, 234, 184, 233, 225, 96, 251, 212, 56, 135, 200, 58, 159, 146, 131, 98, 250, 47, 93, + 165, 221, 95, 225, 186, 180, 91, 163, 13, 223, 67, 133, 115, 61, 43, 64, 11, 5, 4, 102, 76, + 197, 48, 216, 138, 68, 145, 2, 118, 148, 202, 86, 161, 149, 119, 135, 90, 244, 126, 135, + 59, 41, 183, 89, 193, 15, 12, 209, 191, 174, 244, 235, 83, 137, 144, 140, 207, 184, 28, + 253, 9, 253, 193, 61, 232, 244, 46, 141, 168, 121, 200, 135, 237, 244, 30, 193, 58, 130, + 167, 131, 223, 204, 101, 243, 251, 68, 144, 42, 16, 19, 200, 178, 143, 201, 235, 33, 82, + 112, 134, 89, 19, 168, 34, 166, 175, 21, 105, 203, 35, 131, 139, 158, 20, 51, 42, 189, 19, + 139, 249, 97, 177, 169, 199, 155, 186, 118, 128, 235, 18, 226, 25, 29, 228, 228, 219, 55, + 136, 66, 28, 188, 217, 100, 170, 255, 238, 24, 222, 162, 200, 1, 19, 33, 93, 15, 39, 151, + 128, 136, 118, 91, 53, 148, 238, 89, 106, 51, 86, 219, 171, 246, 196, 185, 119, 49, 24, 31, + 221, 33, 151, 150, 149, 90, 1, 120, 6, 118, 2, 172, 9, 94, 243, 189, 223, 60, 83, 20, 141, + 173, 95, 69, 214, 68, 36, 245, 221, 209, 88, 254, 203, 39, 201, 146, 221, 141, 212, 50, + 163, 208, 194, 171, 15, 163, 18, 73, 65, 175, 227, 26, 32, 73, 25, 26, 36, 223, 132, 148, + 12, 228, 216, 150, 247, 1, 247, 78, 56, 47, 118, 206, 106, 43, 53, 215, 28, 26, 225, 4, + 176, 124, 27, 122, 58, 146, 77, 115, 103, 72, 54, 150, 159, 27, 97, 254, 74, 206, 97, 185, + 94, 167, 163, 255, 147, 189, 238, 63, 181, 231, 93, 179, 211, 180, 40, 14, 138, 82, 169, + 75, 111, 55, 190, 155, 19, 91, 218, 218, 180, 176, 89, 232, 4, 255, 176, 56, 10, 120, 64, + 188, 52, 166, 104, 9, 15, 8, 252, 66, 156, 209, 3, 200, 64, 254, 225, 250, 69, 166, 244, + 132, 6, 90, 192, 155, 30, 18, 88, 113, 4, 249, 101, 48, 189, 23, 31, 38, 12, 38, 74, 192, + 176, 112, 55, 26, 159, 6, 49, 47, 111, 111, 176, 112, 232, 166, 94, 180, 227, 201, 81, 48, + 96, 95, 70, 165, 14, 104, 82, 255, 72, 130, 116, 242, 110, 241, 112, 108, 51, 99, 27, 239, + 22, 188, 160, 168, 159, 51, 71, 63, 186, 214, 31, 188, 59, 251, 105, 158, 200, 193, 149, + 45, 74, 234, 237, 211, 227, 194, 74, 97, 165, 235, 209, 73, 130, 108, 57, 89, 203, 127, + 226, 64, 19, 206, 125, 121, 132, 159, 202, 248, 0, 186, 189, 225, 209, 185, 233, 222, 91, + 181, 36, 130, 61, 113, 4, 254, 137, 117, 251, 25, 181, 242, 136, 159, 186, 232, 225, 20, + 205, 215, 39, 151, 99, 223, 4, 73, 240, 145, 59, 106, 186, 5, 17, 139, 31, 112, 12, 16, + 255, 53, 76, 103, 227, 113, 123, 195, 86, 4, 191, 140, 222, 137, 59, 165, 218, 252, 54, + 130, 236, 196, 180, 108, 13, 98, 126, 23, 250, 81, 60, 239, 40, 62, 253, 26, 245, 215, 9, + 125, 34, 199, 185, 67, 91, 85, 78, 19, 0, 135, 237, 146, 139, 218, 43, 214, 82, 234, 164, + 232, 216, 25, 29, 86, 118, 58, 251, 10, 5, 245, 148, 138, 183, 4, 125, 3, 190, 58, 162, + 181, 124, 205, 165, 69, 132, 142, 105, 23, 100, 213, 7, 98, 21, 51, 168, 89, 250, 109, 152, + 224, 128, 103, 191, 132, 209, 16, 112, 118, 191, 6, 37, 6, 173, 113, 175, 155, 0, 30, 205, + 246, 200, 5, 50, 129, 150, 37, 86, 62, 197, 248, 241, 185, 230, 56, 178, 174, 187, 145, + 137, 39, 99, 67, 10, 163, 161, 220, 165, 166, 240, 190, 71, 255, 82, 222, 86, 24, 158, 224, + 184, 160, 187, 205, 37, 24, 28, 157, 96, 93, 74, 85, 245, 49, 203, 224, 57, 87, 204, 182, + 30, 75, 7, 153, 247, 31, 122, 171, 101, 165, 144, 138, 157, 22, 153, 153, 40, 217, 182, + 156, 166, 249, 183, 75, 136, 9, 86, 132, 237, 22, 66, 227, 214, 243, 124, 228, 164, 25, + 230, 113, 139, 90, 160, 45, 238, 71, 19, 79, 43, 252, 190, 80, 151, 131, 86, 144, 173, 63, + 135, 231, 162, 8, 122, 55, 222, 40, 217, 107, 120, 168, 193, 103, 99, 128, 4, 179, 227, + 101, 58, 62, 65, 52, 35, 0, 67, 103, 254, 209, 30, 111, 177, 96, 121, 82, 157, 163, 207, + 95, 155, 241, 7, 205, 152, 254, 170, 43, 132, 151, 97, 119, 205, 70, 201, 64, 63, 230, 100, + 3, 193, 224, 55, 181, 217, 21, 176, 170, 156, 237, 152, 199, 181, 75, 202, 100, 151, 69, + 140, 81, 126, 153, 2, 42, 10, 250, 102, 110, 191, 69, 171, 151, 119, 132, 84, 102, 135, + 236, 100, 245, 157, 156, 144, 146, 54, 200, 230, 239, 36, 148, 57, 230, 2, 119, 82, 213, + 170, 44, 86, 120, 139, 136, 179, 51, 154, 221, 254, 68, 217, 184, 13, 138, 235, 43, 84, 73, + 34, 171, 216, 58, 175, 108, 111, 220, 65, 156, 58, 137, 69, 209, 146, 116, 177, 143, 179, + 239, 34, 187, 175, 250, 144, 227, 62, 242, 221, 41, 209, 225, 208, 200, 203, 12, 227, 105, + 147, 161, 20, 158, 83, 17, 200, 88, 208, 140, 13, 34, 108, 232, 233, 157, 76, 67, 184, 65, + 180, 21, 193, 205, 229, 131, 125, 116, 66, 166, 145, 87, 174, 222, 17, 199, 113, 246, 58, + 56, 39, 255, 45, 8, 222, 142, 119, 179, 146, 239, 166, 24, 57, 234, 92, 113, 192, 7, 180, + 252, 169, 163, 6, 82, 58, 191, 102, 181, 223, 8, 45, 16, 47, 209, 85, 224, 147, 7, 109, + 239, 68, 201, 204, 43, 228, 121, 122, 137, 157, 74, 253, 108, 164, 102, 140, 194, 33, 194, + 216, 117, 144, 85, 222, 218, 113, 1, 229, 149, 250, 196, 15, 210, 119, 200, 69, 32, 216, + 13, 88, 195, 245, 144, 82, 237, 124, 4, 74, 255, 87, 180, 126, 239, 113, 184, 87, 5, 142, + 17, 92, 119, 54, 194, 116, 181, 220, 115, 1, 199, 8, 88, 51, 166, 127, 198, 48, 194, 202, + 40, 97, 11, 160, 198, 57, 16, 128, 80, 10, 32, 167, 179, 158, 45, 9, 107, 43, 197, 32, 138, + 18, 181, 208, 142, 158, 37, 254, 148, 172, 83, 136, 177, 253, 159, 113, 60, 147, 46, 39, + 189, 40, 35, 123, 24, 117, 63, 170, 80, 221, 9, 159, 75, 237, 62, 231, 102, 17, 208, 252, + 223, 240, 86, 129, 187, 222, 6, 59, 157, 37, 19, 166, 123, 16, 219, 185, 52, 223, 192, 241, + 226, 82, 102, 157, 249, 10, 83, 154, 32, 252, 174, 252, 1, 135, 37, 71, 90, 99, 112, 148, + 38, 243, 149, 174, 40, 223, 193, 255, 195, 207, 156, 79, 129, 115, 63, 157, 192, 102, 71, + 103, 204, 204, 126, 242, 61, 216, 252, 159, 17, 144, 165, 56, 41, 20, 111, 70, 61, 37, 114, + 130, 125, 84, 162, 226, 239, 234, 157, 81, 95, 226, 212, 58, 196, 230, 4, 82, 39, 99, 225, + 136, 25, 61, 115, 63, 89, 193, 20, 82, 59, 61, 165, 88, 118, 224, 249, 1, 50, 123, 127, 5, + 47, 29, 40, 67, 103, 44, 120, 21, 245, 225, 208, 7, 162, 144, 94, 220, 221, 10, 243, 220, + 98, 118, 175, 13, 24, 6, 243, 136, 137, 40, 243, 218, 105, 29, 0, 218, 163, 95, 62, 202, + 147, 115, 14, 235, 89, 102, 53, 141, 252, 111, 135, 195, 137, 7, 27, 105, 109, 77, 68, 3, + 109, 59, 28, 38, 83, 61, 158, 143, 145, 196, 226, 154, 50, 22, 180, 241, 103, 127, 23, 246, + 61, 52, 90, 104, 165, 137, 17, 177, 119, 100, 165, 149, 156, 121, 107, 232, 229, 107, 48, + 168, 31, 177, 7, 102, 59, 168, 137, 113, 17, 254, 63, 63, 116, 235, 13, 59, 102, 73, 186, + 196, 168, 75, 203, 143, 58, 158, 90, 86, 77, 42, 248, 193, 175, 196, 102, 157, 11, 240, + 220, 44, 113, 120, 208, 93, 142, 73, 79, 210, 215, 190, 212, 215, 100, 140, 237, 230, 127, + 182, 195, 255, 4, 216, 181, 64, 181, 207, 173, 250, 29, 13, 81, 16, 141, 161, 149, 208, + 254, 136, 21, 58, 70, 197, 211, 129, 115, 92, 56, 180, 92, 153, 160, 219, 179, 59, 130, 26, + 201, 209, 25, 232, 243, 254, 49, 82, 82, 100, 89, 41, 88, 250, 145, 122, 220, 216, 161, + 187, 81, 214, 168, 86, 222, 175, 156, 96, 38, 235, 213, 68, 39, 81, 64, 71, 205, 234, 192, + 31, 15, 105, 0, 60, 80, 132, 49, 206, 247, 219, 126, 102, 136, 42, 138, 102, 219, 18, 33, + 196, 102, 198, 19, 7, 126, 136, 76, 234, 64, 82, 118, 62, 38, 88, 188, 52, 0, 85, 11, 53, + 60, 132, 109, 151, 101, 113, 223, 189, 248, 255, 35, 7, 234, 160, 14, 242, 128, 58, 183, + 14, 210, 171, 179, 116, 92, 254, 58, 218, 199, 107, 62, 7, 73, 191, 138, 167, 199, 132, + 172, 43, 171, 216, 148, 205, 58, 149, 100, 117, 38, 209, 179, 82, 246, 166, 150, 121, 85, + 111, 14, 59, 66, 86, 98, 92, 183, 255, 233, 206, 238, 39, 106, 167, 147, 105, 244, 255, + 154, 140, 21, 30, 75, 151, 172, 89, 23, 74, 0, 204, 53, 64, 158, 253, 96, 61, 206, 239, + 149, 221, 70, 161, 20, 33, 64, 111, 248, 91, 10, 98, 61, 74, 41, 95, 178, 108, 215, 189, + 80, 51, 92, 108, 167, 39, 70, 5, 153, 70, 216, 210, 6, 11, 30, 147, 148, 226, 140, 118, 93, + 65, 196, 161, 157, 110, 11, 187, 68, 157, 228, 113, 113, 245, 15, 116, 16, 113, 83, 63, + 196, 153, 54, 202, 1, 2, 149, 147, 235, 228, 248, 138, 106, 167, 47, 88, 18, 203, 176, 101, + 243, 58, 85, 105, 65, 154, 26, 97, 154, 38, 206, 171, 36, 190, 209, 20, 37, 145, 139, 57, + 238, 238, 130, 163, 50, 248, 122, 35, 229, 145, 143, 135, 191, 226, 16, 100, 81, 117, 250, + 119, 171, 185, 36, 99, 61, 241, 178, 222, 94, 167, 189, 18, 70, 182, 255, 28, 126, 130, + 196, 202, 234, 122, 194, 192, 254, 107, 183, 226, 78, 49, 4, 245, 34, 127, 88, 172, 33, 91, + 103, 225, 93, 14, 124, 109, 66, 213, 88, 118, 254, 41, 0, 33, 50, 201, 153, 190, 113, 242, + 199, 80, 62, 56, 169, 119, 216, 222, 82, 130, 73, 96, 228, 137, 9, 91, 196, 15, 204, 203, + 160, 55, 1, 100, 221, 23, 143, 68, 91, 193, 20, 179, 87, 30, 75, 210, 62, 201, 105, 87, + 110, 29, 3, 65, 105, 116, 123, 204, 52, 147, 197, 11, 7, 14, 18, 123, 32, 93, 133, 177, + 182, 212, 184, 8, 206, 211, 118, 214, 234, 228, 194, 73, 112, 177, 217, 198, 238, 208, 128, + 71, 228, 177, 184, 79, 163, 63, 128, 112, 205, 60, 64, 176, 22, 57, 146, 115, 9, 252, 37, + 72, 40, 94, 27, 160, 66, 141, 181, 229, 248, 185, 153, 183, 145, 140, 140, 18, 207, 220, + 59, 2, 12, 116, 101, 107, 68, 2, 243, 21, 73, 1, 128, 53, 71, 180, 0, 179, 109, 7, 87, 202, + 183, 163, 79, 139, 211, 90, 242, 6, 200, 79, 112, 237, 108, 184, 52, 177, 37, 12, 217, 191, + 112, 37, 100, 30, 2, 235, 186, 224, 44, 254, 191, 234, 65, 46, 247, 54, 27, 106, 54, 199, + 216, 176, 147, 71, 212, 80, 214, 129, 150, 222, 43, 31, 132, 31, 148, 67, 243, 74, 162, 51, + 65, 247, 27, 198, 1, 116, 139, 115, 230, 177, 91, 21, 244, 2, 239, 135, 178, 175, 15, 145, + 42, 107, 173, 2, 143, 55, 120, 69, 21, 206, 168, 174, 59, 119, 217, 165, 80, 91, 51, 66, + 234, 177, 226, 17, 222, 172, 197, 25, 235, 41, 66, 127, 42, 245, 78, 81, 29, 170, 46, 222, + 215, 11, 219, 178, 147, 29, 148, 50, 242, 147, 218, 61, 192, 68, 59, 86, 83, 23, 62, 224, + 220, 62, 241, 208, 24, 212, 165, 100, 58, 61, 119, 112, 17, 46, 88, 1, 221, 151, 117, 216, + 238, 234, 205, 128, 46, 152, 94, 212, 170, 194, 107, 191, 49, 125, 239, 119, 28, 228, 134, + 171, 212, 53, 42, 14, 239, 51, 104, 17, 145, 238, 231, 166, 98, 63, 40, 41, 75, 80, 97, + 101, 109, 139, 199, 215, 117, 169, 171, 174, 43, 71, 85, 120, 127, 190, 0, 12, 15, 42, 50, + 55, 60, 125, 144, 242, 14, 52, 58, 81, 93, 121, 124, 131, 159, 173, 178, 211, 28, 75, 118, + 120, 164, 32, 46, 183, 246, 21, 67, 93, 97, 173, 177, 184, 198, 201, 207, 228, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 14, 20, 30, 42, 47, 51, 62, + ]; + assert!(check( + &message, + &sk_bytes, + &expected_pk_bytes, + &expected_sig_bytes + )); +} diff --git a/third_party/dilithium/tests/sign.rs b/third_party/dilithium/tests/sign.rs new file mode 100644 index 0000000..431787f --- /dev/null +++ b/third_party/dilithium/tests/sign.rs @@ -0,0 +1,65 @@ +extern crate dilithium; +extern crate rng256; + +use dilithium::sign::{PubKey, SecKey}; +use rng256::Rng256; + +const ITERATIONS: u32 = 500; + +#[test] +fn test_sk_with_pk() { + let mut rng = rng256::ThreadRng256 {}; + for _ in 0..ITERATIONS { + let (sk, pk) = SecKey::gensk_with_pk(&mut rng); + let pk_from_sk = sk.genpk(); + assert_eq!(pk, pk_from_sk); + } +} + +#[test] +fn test_sign() { + let mut rng = rng256::ThreadRng256 {}; + for _ in 0..ITERATIONS { + let sk = SecKey::gensk(&mut rng); + + let mut message = [0; 59]; + rng.fill_bytes(&mut message); + let sig = sk.sign(&message); + + let pk = sk.genpk(); + + let mut bytes = [0; dilithium::params::PK_SIZE_PACKED]; + pk.to_bytes(&mut bytes); + assert!(pk.verify(&message, &sig)); + + message[2] ^= 42; + assert!(!pk.verify(&message, &sig)); + } +} + +#[test] +fn test_seckey_to_bytes_from_bytes() { + let mut rng = rng256::ThreadRng256 {}; + + for _ in 0..ITERATIONS { + let sk = SecKey::gensk(&mut rng); + let mut bytes = [0; dilithium::params::SK_SIZE_PACKED]; + sk.to_bytes(&mut bytes); + let decoded_sk = SecKey::from_bytes(&bytes); + assert_eq!(decoded_sk, sk); + } +} + +#[test] +fn test_pubkey_to_bytes_from_bytes() { + let mut rng = rng256::ThreadRng256 {}; + + for _ in 0..ITERATIONS { + let sk = SecKey::gensk(&mut rng); + let pk = sk.genpk(); + let mut bytes = [0; dilithium::params::PK_SIZE_PACKED]; + pk.to_bytes(&mut bytes); + let decoded_pk = PubKey::from_bytes(&bytes); + assert_eq!(decoded_pk, pk); + } +} diff --git a/third_party/dilithium/tests/testvectors.txt b/third_party/dilithium/tests/testvectors.txt new file mode 100644 index 0000000..22e7188 --- /dev/null +++ b/third_party/dilithium/tests/testvectors.txt @@ -0,0 +1,70 @@ +count = 0 +seed = 061550234D158C5EC95595FE04EF7A25767F2E24CC2BC479D09D86DC9ABCFDE7056A8C266F9EF97ED08541DBD2E1FFA19810F5392D076276EF41277C3AB6E94A4E3B7DCC104A05BB089D338BF55C72CA +mat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s = 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 +y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w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c = 000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000001007FE0000000000000000000000000010000000000000000007FE00000000000000000000000000000000000007FE00000000000007FE0000000000000000000007FE0000000000100000000000000000000000100000000007FE0000000000000000000007FE0000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007FE0000000000000000000007FE0000000000000000000000000000000000000000000007FE000000000000000000000000000000000000000000000000000000000010000000000000001000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000007FE000000000000000000000000001000000000000000100000001000000000000000000000000007FE000000000000000000000000000007FE000007FE0000000000000000000000000000000000000000000000000000000000100000000000000000000000000000001000000010000000100000000000000000000000000000000000000000000000000000000007FE000007FE0000000000000000000000000000000000000000000007FE0000000000000000000000000010000000000000000000000000000000000000000000000000000000100000000007FE00000000000000000000000000000000000007FE000007FE000000000000000000100000000007FE000000000000000000000000000000000000000000000000000007FE0000000000000000000007FE00000000000007FE000000000000000000000000000000000000000000100000000000000000000000000000000007FE0000000000000000000007FE0000000000000000001007FE0000000000000000000000000010000000000000000000000010000000000000000007FE00000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007FE00000000000007FE0000000000000000001000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000007FE000000000010000000000000000 +count = 1 +seed = 3085765770296056678AE5E70137324F6CC0DACA6E11275A42584426ED476DAFECB40DC217E9F371279DA5434F223101B35A5A11F541125658E4B5DC1E223C7A068A82D0376A8C56022D02A2245EA96F +mat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s = 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 +y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w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c = 007FE0000000000000000001000000000000000000000000007FE00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000007FE00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000001007FE000000000010000000000000000007FE000000000000000000000000000007FE000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007FE00000000000000000000000000000000000000000000000000000000000000000000000000000000000007FE000000000000000000000000000000000000000000000000000007FE0000000000000000000007FE00000000001000000000000000000000001007FE0000000000000000000007FE000000000000000000000000001007FE000007FE0000000000000000000007FE000007FE000000000000000000000000000000000000000000000000000007FE00000000000000000000000000100000000007FE000000000000000000000000000000000010000000000000000007FE0000000000100000000000000000000000000000001000000000000000000000001000000000000000100000000007FE0000000000000000000000000000000000000000000007FE000000000010000000000000000000000000000000100000000000000000000000000000000000000000000000000000001000000000000000000000001007FE00000000000007FE00000000000000000000000000000000001007FE00000000000007FE0000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000007FE0000000000000000001007FE00000000000000000000000000000000000007FE00000000001007FE0000000000000000000007FE00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000001007FE000000000010000000000000000000000000000000000000000007FE000 +count = 2 +seed = 6DBA85117D8D19AE9CE470498AFA16B3B4CBDFC5536A849D8DDF5135FD7A07DD478AEF2D22B2AEEFE3A2714D68C70193864CC5B516C451781746EC7DDD6A7F10BB01B9FDECE1C9244D2CB236E9321135 +mat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s = 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 +y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w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c = 000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000010000000000000000000000000000000000000000007FE00000000000000000000000000000000001000000000000000000000000000000000000000000000000007FE0000000000000000000000000000000000000000000007FE00000000000007FE000007FE000007FE00000000000000000000000000000000000007FE0000000000000000000007FE000000000000000000000000000000000000000000000000000007FE000000000000000000000000001000000000000000000000000007FE00000000000000000000000000000000000007FE000000000000000000000000000007FE00000000000000000000000000100000000007FE000007FE00000000000000000000000000000000000000000000000000000000000007FE000000000000000000000000001000000000000000000000001007FE0000000000000000000007FE000000000000000000100000000000000000000000000000000007FE000000000010000000000000000000000000000000000000000000000000000000000000000007FE000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000007FE000000000000000000000000000007FE000000000000000000000000000000000010000000000000000000000000000000000000001007FE0000000000100000000007FE0000000000000000000000000000000000000000000000000000000000000000000007FE000007FE000000000000000000000000000000000000000000000000000007FE00000000000000000010000000000000001000000000000000000000000000000010000000000000000007FE0000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000007FE00000000000000000010000000000000000000000000000000000000000000000010000000000000000000000010000000000000000007FE00000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007FE000007FE000000000010000000000000000000000010000000000000000007FE0000000000000000000000000000000000000000000007FE000000000000000000000000000000000000000000000000000007FE0000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000007FE00000000000 +count = 3 +seed = 41472DA93975B121F02017777C317AE8DCB3AB57BF86CF9CB694169D407353807017E24690E0AB4801CAB443484278062D8FE93D08C9B4DE8791BE8B082DC44406FA202EC124773BE2340EF691980161 +mat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s = 007FE003007FDFFC007FE004007FE000007FDFFE007FE000007FDFFC007FE001007FE004007FE006007FE003007FDFFD007FDFFC007FE004007FE004007FDFFC007FE005007FE006007FE000007FDFFE007FE000007FE004007FE001007FE001007FE002007FE006007FE005007FDFFF007FE001007FE003007FDFFF007FDFFC007FDFFE007FE001007FE006007FE005007FE002007FE003007FE004007FDFFE007FE006007FDFFC007FE006007FE000007FE002007FE000007FE003007FE005007FE000007FE002007FDFFC007FE006007FE005007FE002007FE004007FE002007FE003007FE006007FDFFD007FE005007FE003007FDFFC007FE001007FDFFD007FDFFC007FE000007FDFFF007FDFFD007FE005007FDFFD007FDFFF007FE003007FDFFF007FE006007FE004007FE000007FDFFE007FDFFF007FE003007FE000007FDFFD007FE005007FDFFD007FE005007FE002007FE000007FDFFF007FDFFF007FDFFE007FDFFD007FE006007FE000007FDFFC007FDFFD007FE000007FE006007FDFFC007FE004007FE005007FE000007FE006007FE000007FE006007FE000007FE004007FDFFE007FE005007FDFFE007FE000007FE001007FDFFD007FDFFF007FE005007FE003007FE004007FE001007FE003007FE004007FDFFF007FE006007FE006007FDFFF007FE006007FDFFF007FE001007FE005007FE000007FDFFD007FE003007FE000007FDFFD007FE004007FE006007FDFFF007FDFFF007FE005007FDFFD007FDFFD007FE004007FE005007FDFFF007FE002007FDFFE007FDFFD007FE005007FE005007FE000007FE002007FE000007FDFFF007FE004007FE000007FE003007FDFFF007FDFFD007FDFFC007FE001007FE001007FE003007FDFFE007FE005007FDFFE007FE000007FDFFF007FDFFF007FDFFF007FE004007FE004007FE000007FE006007FDFFE007FDFFE007FE003007FE003007FE002007FDFFD007FDFFC007FE004007FE001007FE002007FDFFC007FE000007FE000007FDFFE007FE006007FDFFC007FDFFC007FE000007FDFFD007FE003007FDFFE007FDFFE007FE006007FE002007FE006007FE002007FDFFC007FE003007FE000007FDFFD007FDFFF007FDFFC007FE004007FDFFC007FE003007FDFFC007FE004007FE001007FDFFD007FE003007FE005007FDFFE007FE001007FDFFD007FE004007FDFFD007FE002007FE002007FE006007FE001007FE003007FE003007FE002007FE000007FE003007FE001007FDFFE007FE006007FE000007FE003007FE005007FDFFC007FDFFE007FDFFE007FE001007FE006007FE004007FDFFC007FDFFF007FE000007FDFFC007FE006007FDFFD007FDFFF007FDFFF007FDFFD007FE006007FE004007FE002007FE000007FDFFD007FE002007FE001007FE005007FDFFE007FE005007FDFFC007FE000007FE004007FDFFF007FE000007FDFFE007FDFFD007FE000007FE001007FE002007FE002007FE002007FDFFD007FE006007FDFFD007FDFFD007FE001007FDFFD007FDFFF007FE005007FE002007FDFFC007FE004007FDFFD007FE005007FDFFC007FE000007FE001007FDFFE007FE005007FDFFD007FDFFF007FE006007FDFFF007FDFFF007FE001007FE002007FDFFF007FE002007FDFFD007FE002007FE005007FDFFD007FE004007FDFFC007FE006007FE001007FE000007FE006007FE005007FE003007FE005007FDFFE007FDFFE007FE004007FDFFD007FE001007FE003007FDFFC007FE005007FDFFE007FE006007FE006007FE000007FE002007FE002007FE004007FE006007FE003007FDFFD007FE003007FE005007FE002007FE004007FE005007FE000007FE006007FE002007FE005007FE004007FDFFC007FDFFF007FE005007FDFFE007FDFFF007FDFFE007FDFFE007FE005007FDFFE007FE006007FDFFC007FE003007FE004007FE004007FE002007FDFFC007FE000007FE002007FDFFF007FE001007FDFFF007FDFFC007FE001007FDFFD007FE002007FE005007FDFFF007FE000007FDFFD007FE006007FE003007FE005007FE002007FE001007FE002007FE000007FE000007FDFFE007FE001007FE004007FE003007FE003007FE003007FE002007FE000007FE006007FDFFC007FE001007FE001007FE006007FDFFD007FE005007FE000007FDFFD007FE005007FE006007FDFFD007FDFFF007FE002007FDFFE007FE002007FDFFC007FDFFD007FDFFE007FDFFC007FDFFD007FDFFD007FDFFD007FE005007FE002007FE006007FDFFC007FE004007FE002007FDFFE007FDFFF007FE004007FDFFE007FDFFE007FDFFC007FE004007FE005007FE001007FE001007FDFFF007FE003007FE001007FE001007FE001007FE000007FE006007FE006007FE005007FE006007FE000007FE000007FDFFF007FE006007FE001007FDFFF007FDFFD007FDFFF007FDFFD007FE006007FE002007FE003007FDFFF007FE001007FE004007FE004007FE002007FDFFC007FE004007FE006007FE004007FDFFC007FE004007FDFFD007FE002007FE002007FE001007FE006007FE000007FE005007FE001007FE002007FE001007FDFFF007FE001007FE000007FDFFC007FE002007FE002007FE004007FE006007FE000007FDFFC007FE006007FDFFC007FE000007FE000007FDFFC007FE006007FDFFE007FE005007FDFFE007FE004007FE000007FE006007FE001007FDFFD007FE005007FE002007FDFFE007FE005007FE006007FE003007FDFFF007FE005007FDFFE007FE003007FE006007FE000007FDFFF007FDFFF007FDFFC007FDFFE007FDFFC007FE006007FDFFE007FDFFE007FDFFC007FE004007FE002007FE006007FE001007FE000007FDFFC007FDFFC007FDFFD007FE006007FDFFD007FDFFD007FE004007FE006007FE006007FE002007FE004007FE004007FE004007FE001007FE006007FE005007FE006007FE002007FDFFE007FDFFF007FE002007FDFFC007FE003007FE000007FDFFD007FDFFE007FE003007FDFFC007FE002007FE004007FE005007FE006007FE000007FE001007FE002007FE003007FDFFE007FDFFE007FE004007FE005007FE000007FDFFD007FE000007FE002007FE006007FE005007FE006007FE006007FE006007FDFFE007FE000007FDFFE007FE003007FE006007FE001007FDFFE007FDFFC007FE005007FE000007FE006007FE001007FDFFD007FE004007FE000007FE004007FE006007FE000007FDFFF007FDFFD007FE005007FDFFC007FE006007FDFFF007FDFFE007FE002007FE006007FE000007FE003007FE005007FDFFD007FDFFE007FDFFF007FDFFD007FDFFC007FE003007FE003007FE006007FDFFF007FDFFE007FE006007FE001007FE006007FE006007FE000007FE000007FE002007FDFFF007FDFFE007FE003007FDFFD007FE001007FE006007FE004007FE003007FE003007FE006007FDFFC007FDFFF007FE004007FDFFF007FE004007FDFFD007FE005007FE006007FE003007FE005007FE003007FE001007FDFFD007FDFFD007FE003007FE004007FE005007FE006007FE003007FDFFC007FE001007FE006007FE005007FDFFD007FDFFC007FE002007FDFFE007FDFFE007FDFFD007FDFFF007FE001007FE004007FE005007FDFFE007FE004007FE000007FDFFC007FE005007FDFFF007FDFFD007FE002007FDFFC007FDFFE007FE005007FE001007FE005007FE004007FE001007FDFFF007FE004007FE004007FE002007FDFFF007FE003007FDFFD007FE001007FE000007FE004007FDFFE007FE000007FDFFE007FDFFF007FE005007FE002007FE004007FE001007FE006007FDFFD007FE006007FDFFC007FE005007FDFFD007FDFFE007FE005007FE004007FE005007FE004007FDFFF007FE003007FE003007FE000007FE002007FE004007FDFFC007FE004007FDFFD007FE005007FE002007FE005007FE002007FE005007FE005007FE005007FE006007FE001007FE005007FDFFE007FDFFE007FDFFC007FE006007FE001007FE004007FE004007FE003007FE002007FE005007FE003007FE002007FDFFC007FE005007FDFFC007FE000007FE003007FDFFF007FDFFC007FE002007FE000007FDFFE007FDFFC007FE000007FE005007FE001007FE003007FE002007FE003007FDFFE007FE004007FE004007FE003007FDFFD007FE005007FDFFE007FE001007FDFFD007FE005007FE002007FE002007FDFFF007FE000007FDFFD007FE004007FE001007FE005007FDFFE007FDFFD007FE003007FE003007FE003007FE001007FE006007FDFFC007FE002007FDFFD007FE005007FDFFD007FE004007FE001007FE002007FE006007FDFFC007FDFFC007FE000007FDFFF007FE004007FE006007FE001007FE002007FDFFD007FE004007FDFFF007FDFFD007FDFFE007FDFFC007FE001007FE004007FDFFD007FE005007FE000007FE006007FE001007FE000007FDFFE007FE002007FDFFE007FE001007FDFFD007FE000007FDFFD007FE004007FE004007FDFFD007FE001007FE002007FE003007FDFFC007FDFFC007FE005007FDFFC007FE006007FE003007FDFFC007FE003007FE002007FDFFF007FDFFC007FE002007FDFFC007FE004007FE006007FE002007FE005007FDFFD007FE002007FDFFE007FDFFF007FDFFE007FDFFE007FE000007FE004007FE002007FE001007FE005007FE004007FDFFD007FE004007FE004007FDFFD007FDFFF007FE006007FE006007FE001007FE002007FDFFC007FE000007FE001007FE004007FE003007FE001007FDFFC007FDFFE007FDFFE007FE004007FE005007FDFFC007FE004007FDFFD007FE000007FE002007FE003007FE006007FDFFC007FDFFE007FE001007FDFFF007FE003007FDFFD007FE003007FE003007FDFFF007FE000007FDFFF007FDFFF007FDFFF007FE002007FDFFC007FE003007FE002007FE004007FE002007FE002007FE006007FE004007FE005007FDFFF007FE000007FE006007FE004007FE005007FE002007FE003007FDFFD007FE004007FE002007FE006007FE001007FDFFE007FE003007FE002007FDFFF007FE004007FE001007FE000007FE001007FDFFD007FE006007FE005007FDFFF007FDFFF007FE006007FDFFE007FE001007FE005007FDFFF007FDFFE007FDFFC007FDFFD007FDFFC007FE001007FDFFF007FDFFC007FE004007FE001007FE004007FDFFC007FE000007FE004007FE006007FDFFF007FDFFF007FDFFF007FE005007FDFFE007FE001007FE002007FDFFE007FDFFE007FDFFF007FE004007FE004007FE006007FE002007FDFFF007FE005007FE003007FE006007FE006007FDFFF007FDFFE007FE005007FE003007FDFFF007FE003007FE004007FE006007FDFFD007FDFFD007FDFFD007FE006007FDFFF007FE005007FE003007FE002007FE002007FE000007FDFFF007FE005007FE001007FE006007FE003007FE003007FE001007FE004007FDFFD007FDFFD007FDFFE007FE001007FE006007FDFFF007FDFFE007FE004007FDFFD007FE001007FDFFC007FDFFE007FE005007FE000007FE001007FE002007FE001007FE001007FE003007FDFFF007FDFFF007FDFFC007FE006007FDFFF007FE005007FE006007FE005007FE001007FE001007FDFFF007FDFFD007FE001007FDFFC007FDFFC007FE001007FE002007FE005007FDFFF007FE001007FDFFD007FDFFE007FE003007FDFFE +y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w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c = 0000000000000000007FE000000000000000000000000000000000010000000000000000000000010000000000000000000000000000000100000000000000000000000000000000007FE0000000000000000000007FE000000000000000000000000000000000000000000000000000007FE00000000000000000000000000100000000000000000000000000000000000000000000000100000000007FE000007FE00000000000007FE00000000001000000010000000000000000000000000000000000000000000000000000000000000000007FE000007FE0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000007FE00000000000000000000000000000000000000000000000000100000001007FE000007FE00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000007FE00000000000000000000000000000000001007FE0000000000100000000000000010000000000000000007FE00000000000000000000000000000000000007FE00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000007FE000000000010000000000000000000000010000000000000000000000000000000000000001007FE0000000000000000000007FE0000000000000000000007FE00000000000000000000000000000000000000000000000000000000000007FE000007FE000000000000000000000000000007FE00000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000007FE0000000000000000000007FE000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007FE000000000000000000000000001000000000000000000000000000000010000000000000000000000010000000000000000000000000000000000000000000000000000000100000000007FE00000000000000000000000000100000000007FE00000000000000000010000000000000000000000000000000000000000000000000000000000000000007FE0000000000000000001007FE0000000000000000000007FE000007FE0000000000100000000 +count = 4 +seed = 378281A9D7AF06C7E31EEEA95AF420BB262618639E1EFCBBFB683ECD2638C56DE5FD0BFEC896346655D4EFC128D30A918246F0FFCDA950E4E035160DFBC51D79B46B1485EF602F88906BB1A557CEC702 +mat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s = 007FDFFD007FE004007FE005007FE005007FDFFC007FE006007FE004007FE003007FE001007FE006007FDFFC007FDFFC007FDFFC007FE001007FDFFC007FDFFC007FE004007FE003007FDFFF007FDFFF007FE006007FDFFF007FE004007FDFFD007FE000007FDFFE007FE006007FE006007FE003007FE000007FDFFD007FDFFF007FE002007FE001007FE001007FE004007FE004007FDFFF007FDFFD007FDFFD007FE005007FDFFF007FDFFF007FE003007FE006007FDFFE007FE003007FE001007FE001007FE005007FE004007FE000007FE003007FE006007FE006007FDFFC007FE005007FDFFF007FE004007FE001007FDFFC007FDFFC007FE002007FDFFD007FE001007FDFFC007FE002007FE001007FDFFE007FDFFC007FDFFF007FE000007FE004007FDFFF007FDFFD007FE001007FE001007FE003007FDFFC007FDFFE007FE005007FE004007FE002007FDFFE007FE000007FE003007FDFFE007FE006007FDFFD007FDFFF007FE006007FDFFC007FE001007FE001007FE000007FE003007FE005007FDFFE007FE001007FE004007FDFFE007FE006007FDFFC007FE000007FDFFE007FE006007FDFFE007FDFFE007FE006007FE006007FDFFD007FE004007FDFFD007FDFFF007FE002007FDFFC007FE006007FE006007FE006007FE004007FDFFC007FE000007FE000007FE005007FE003007FE005007FE004007FDFFF007FDFFF007FE003007FE002007FE000007FE006007FE003007FE000007FE000007FDFFC007FDFFE007FE000007FE000007FDFFF007FE005007FDFFD007FE000007FE002007FE006007FE002007FE002007FE000007FE005007FE003007FE003007FE001007FDFFD007FDFFC007FE006007FE002007FDFFE007FE005007FE004007FE002007FE002007FE006007FDFFE007FE000007FE001007FDFFE007FDFFF007FDFFC007FE001007FE001007FE005007FE000007FDFFE007FE000007FE001007FE005007FDFFE007FDFFF007FDFFF007FE000007FDFFD007FE004007FE004007FDFFF007FE004007FDFFF007FE006007FE005007FE004007FDFFE007FDFFC007FDFFE007FE003007FE002007FDFFE007FE004007FDFFF007FE002007FDFFC007FDFFF007FE000007FDFFD007FE003007FE002007FE005007FE000007FDFFD007FE006007FE000007FDFFC007FDFFF007FDFFC007FE003007FDFFD007FE003007FE005007FE003007FDFFD007FE003007FDFFC007FE003007FE004007FE000007FE001007FDFFF007FE002007FE004007FE005007FE001007FDFFC007FDFFE007FE004007FE001007FDFFC007FE003007FDFFC007FDFFC007FE001007FE003007FE000007FE000007FE000007FE002007FDFFE007FDFFE007FDFFE007FDFFE007FDFFD007FE006007FDFFF007FE002007FE006007FE006007FE001007FE006007FDFFD007FDFFD007FDFFE007FE006007FE002007FDFFC007FDFFC007FDFFC007FDFFF007FE000007FE003007FDFFC007FDFFD007FE003007FDFFD007FDFFC007FE000007FDFFE007FDFFE007FE001007FDFFD007FE002007FE002007FDFFE007FE003007FDFFD007FE002007FE000007FDFFC007FE006007FDFFD007FDFFE007FDFFD007FE003007FE004007FE000007FDFFC007FE004007FDFFD007FDFFD007FE000007FE000007FE003007FDFFE007FE005007FDFFD007FE000007FDFFE007FDFFD007FDFFF007FDFFD007FE006007FE001007FDFFC007FE000007FDFFE007FE004007FDFFE007FE001007FDFFC007FE002007FE006007FE001007FE005007FDFFE007FE002007FE005007FE004007FE002007FDFFD007FDFFD007FE001007FE004007FE002007FE000007FDFFD007FDFFD007FDFFE007FE000007FE005007FE000007FDFFD007FDFFF007FE006007FDFFC007FE004007FE006007FE006007FE003007FE003007FDFFD007FDFFD007FDFFF007FE001007FE001007FE001007FE005007FDFFE007FDFFF007FE003007FE004007FE003007FE002007FE003007FE004007FDFFC007FE006007FE003007FE003007FE001007FE004007FDFFC007FDFFF007FDFFE007FDFFE007FE000007FE002007FE001007FE004007FE005007FDFFE007FDFFC007FE001007FE005007FDFFE007FDFFC007FE001007FE004007FE005007FE003007FE002007FE002007FE000007FDFFD007FE001007FE006007FDFFF007FE004007FDFFE007FE000007FDFFE007FE001007FDFFD007FDFFC007FE006007FDFFE007FE006007FE001007FE005007FDFFD007FE004007FE002007FDFFD007FE006007FE006007FE002007FE005007FE002007FDFFF007FE005007FDFFD007FE000007FE003007FDFFE007FDFFD007FE004007FDFFD007FDFFD007FE004007FE001007FDFFC007FE006007FDFFD007FE003007FE003007FE002007FE005007FE005007FE003007FE001007FE005007FDFFD007FE004007FE006007FE005007FDFFC007FDFFD007FDFFC007FE001007FE005007FDFFC007FDFFE007FE004007FE004007FE004007FDFFE007FDFFF007FDFFD007FDFFE007FE003007FE006007FDFFE007FE000007FE006007FE002007FDFFE007FE005007FE001007FE000007FE000007FDFFE007FDFFC007FE003007FE000007FE004007FE006007FE005007FE006007FDFFC007FE001007FE003007FDFFF007FDFFD007FE001007FE002007FDFFD007FE001007FDFFF007FE004007FE006007FDFFF007FE001007FE006007FE000007FDFFE007FE006007FE001007FE001007FDFFE007FE003007FDFFF007FE000007FDFFD007FE000007FE001007FDFFE007FE006007FDFFE007FE002007FE006007FE005007FE005007FE006007FDFFC007FDFFE007FE003007FE005007FE005007FE001007FE000007FE000007FE001007FE001007FE001007FE000007FE004007FE003007FE003007FDFFF007FE004007FE006007FDFFF007FDFFF007FE005007FDFFF007FE004007FDFFE007FDFFD007FDFFC007FE001007FDFFD007FE005007FDFFE007FE003007FE005007FE001007FE000007FE001007FE000007FE005007FE000007FE004007FE006007FE002007FDFFD007FE003007FE002007FDFFF007FDFFF007FDFFC007FE003007FDFFD007FDFFE007FDFFF007FDFFD007FE001007FE003007FE002007FDFFD007FE000007FE000007FDFFC007FE002007FE002007FE000007FDFFF007FE006007FDFFD007FE004007FE003007FE000007FE002007FE003007FDFFC007FDFFC007FE006007FDFFF007FE000007FE004007FDFFC007FDFFC007FDFFC007FE003007FDFFD007FE006007FE001007FDFFF007FDFFD007FDFFD007FE001007FE003007FDFFE007FE001007FDFFD007FE000007FDFFF007FDFFC007FE004007FDFFD007FE002007FE002007FDFFC007FE003007FE000007FE001007FE005007FDFFF007FE001007FE002007FE002007FE001007FE001007FE005007FDFFD007FDFFC007FE001007FE004007FDFFE007FDFFC007FE001007FE000007FE005007FE005007FE006007FE001007FE002007FDFFF007FE003007FE002007FE004007FDFFD007FE001007FE001007FDFFC007FE004007FDFFE007FE001007FDFFD007FDFFC007FE001007FE005007FDFFF007FE001007FDFFE007FE000007FDFFC007FE003007FE000007FE005007FE001007FE001007FE000007FDFFF007FDFFF007FE001007FE001007FDFFD007FE001007FE002007FDFFC007FE003007FE001007FE000007FDFFF007FE001007FE004007FDFFD007FE002007FE006007FDFFC007FDFFD007FE001007FE004007FDFFD007FE003007FE002007FE002007FDFFE007FE004007FDFFF007FE000007FDFFC007FE000007FE006007FE004007FE000007FE004007FE000007FE006007FE002007FE004007FDFFD007FE006007FDFFF007FDFFC007FE005007FE005007FDFFF007FE001007FE003007FDFFF007FE001007FE004007FDFFF007FE000007FDFFD007FE001007FE001007FE002007FE002007FE005007FDFFE007FDFFF007FDFFE007FE005007FDFFC007FDFFE007FE004007FDFFD007FDFFE007FE000007FE003007FE004007FE005007FE005007FE005007FE001007FE003007FE003007FE006007FDFFE007FDFFE007FE000007FDFFD007FDFFC007FE006007FDFFF007FE006007FE002007FDFFC007FDFFE007FDFFF007FE000007FE006007FE001007FE001007FE000007FE003007FDFFC007FE004007FE006007FDFFE007FDFFD007FE004007FE004007FDFFD007FE000007FE001007FE001007FE002007FE005007FDFFD007FE002007FE001007FDFFE007FDFFE007FE001007FE001007FE002007FE003007FE004007FE001007FE006007FDFFD007FE006007FDFFE007FE003007FDFFC007FE004007FE001007FE006007FDFFF007FE002007FE005007FDFFE007FE006007FE006007FE004007FE006007FE005007FE006007FE001007FE005007FE000007FE005007FE004007FE005007FDFFC007FE006007FDFFC007FE005007FE004007FE004007FDFFD007FE004007FE002007FE000007FDFFF007FDFFD007FE000007FE004007FDFFE007FE005007FDFFF007FE006007FDFFF007FE005007FE006007FDFFE007FE002007FE006007FE000007FDFFE007FDFFC007FDFFD007FDFFC007FE006007FE003007FE004007FE002007FDFFC007FE003007FE005007FDFFC007FDFFC007FE000007FE001007FE005007FE000007FE002007FDFFC007FE002007FDFFD007FE004007FE000007FE003007FE006007FDFFD007FDFFE007FDFFF007FDFFE007FDFFE007FE005007FDFFC007FE003007FE003007FE002007FE004007FDFFC007FE005007FE000007FDFFE007FE004007FDFFD007FE001007FDFFE007FE004007FE001007FE001007FE005007FE000007FE001007FDFFD007FE000007FDFFF007FDFFC007FE005007FE000007FE001007FDFFF007FE002007FE002007FDFFE007FE004007FE004007FE000007FE001007FE003007FE003007FE001007FE002007FDFFF007FE003007FE000007FE004007FDFFE007FE004007FE006007FE004007FE003007FDFFD007FE002007FE002007FDFFF007FDFFF007FDFFF007FDFFF007FE006007FE002007FE006007FDFFE007FE000007FE001007FE001007FDFFC007FDFFD007FE000007FE003007FE006007FE001007FE006007FE004007FE002007FE006007FE001007FE003007FDFFE007FDFFC007FE000007FE002007FE004007FE004007FE001007FE002007FE001007FE002007FE005007FDFFF007FE003007FE002007FE004007FDFFF007FDFFD007FE005007FE002007FDFFF007FDFFF007FDFFC007FE006007FE002007FDFFD007FE001007FE001007FE004007FE006007FE002007FDFFC007FE004007FE002007FE001007FDFFE007FDFFD007FE004007FE002007FE003007FE004007FE003007FDFFE007FE003007FDFFE007FDFFE007FE001007FDFFF007FE006007FE005007FE003007FDFFF007FE001007FE002007FE005007FE002007FE000007FDFFC007FE005007FDFFE007FE005007FE002007FE001007FE000007FDFFD007FDFFD007FE003007FE006007FE004007FDFFF007FE002007FDFFF007FE003007FDFFE007FE003007FDFFE007FE006007FDFFF007FE001007FE002007FE004007FDFFF007FE005007FE001007FDFFD007FDFFD007FE001007FDFFC007FE005007FE003007FE005007FDFFC007FE006 +y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w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c = 0000000000000000000000000000000000000000000000000000000000000001007FE000000000000000000000000000007FE000007FE000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000100000000007FE000007FE00000000000000000000000000000000000007FE00000000000000000000000000000000000000000000000000000000000000000000000000000000000007FE0000000000000000000000000010000000000000000007FE0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007FE00000000001007FE000000000010000000000000000000000000000000000000000000000000000000000000000007FE000000000000000000000000000000000000000000000000000000000000000000000000000007FE00000000000000000000000000100000000007FE0000000000000000000000000000000000000000000007FE00000000000007FE00000000001000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001007FE000000000000000000000000000000000000000000000000001000000000000000000000000007FE000007FE0000000000000000000000000000000000000000000000000000000000000000000007FE000007FE0000000000100000000007FE00000000000000000000000000000000000007FE00000000000007FE000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007FE0000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000010000000100000000007FE0000000000000000000007FE00000000000000000000000000100000000000000010000000000000000007FE000007FE000000000010000000000000000000000000000000000000001000000000000000000000000007FE0000000000000000000000000000000000000000000000000000000000000000000007FE0000000000100000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000007FE000007FE000007FE00000000000000000000000000000000001000000000000000000000000007FE0000000000000000000000000000000000000000000007FE0000000000100000000007FE000000000000000000000000000 +count = 5 +seed = 9740100AFB1F91F135BF31C46427F471AF4F9D79B65D2CC27F4DD92E79C246810D774485137D8D8732F0214E974BB9D85494BA20E6B2D26E07FBC2FA98769DDEF6E00019B396322C43CF3AF6C8377342 +mat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s = 007FE004007FE001007FE002007FDFFC007FE003007FE006007FDFFD007FDFFD007FE002007FE000007FE006007FE004007FDFFD007FDFFD007FE004007FDFFC007FE000007FE005007FE004007FDFFE007FDFFC007FE005007FE003007FE002007FE001007FE006007FE004007FE006007FE000007FDFFC007FDFFE007FE001007FDFFC007FDFFC007FE006007FE001007FE002007FE005007FE003007FE002007FE002007FDFFC007FE001007FE001007FDFFC007FDFFE007FE004007FDFFF007FDFFF007FE002007FDFFF007FE000007FE002007FE005007FE000007FDFFE007FE001007FE001007FE002007FE005007FE001007FE005007FDFFC007FE000007FE006007FDFFD007FDFFD007FDFFE007FDFFD007FE002007FE000007FE002007FE006007FE005007FE004007FDFFC007FE002007FE004007FDFFC007FE005007FDFFF007FE004007FE003007FE004007FE000007FDFFF007FE001007FE003007FE004007FE005007FE006007FE002007FE005007FE002007FE005007FDFFD007FE001007FE006007FE000007FE006007FDFFE007FDFFF007FE006007FE000007FDFFE007FE000007FDFFD007FDFFF007FE005007FE003007FE002007FDFFC007FDFFD007FE000007FDFFF007FE000007FE003007FE000007FDFFE007FE005007FDFFF007FE006007FE001007FDFFC007FE001007FDFFD007FE001007FDFFF007FE004007FE002007FDFFE007FDFFC007FDFFF007FE006007FE000007FE002007FE003007FE004007FDFFF007FE004007FE000007FDFFC007FE005007FE006007FDFFE007FDFFF007FDFFC007FDFFF007FE005007FDFFF007FDFFF007FE005007FE002007FDFFC007FDFFC007FE000007FE003007FDFFD007FE003007FE005007FE003007FE003007FE004007FE005007FDFFD007FE002007FDFFF007FE006007FE003007FE006007FE005007FE001007FE005007FE002007FDFFD007FDFFC007FE006007FE004007FE006007FE003007FDFFD007FE000007FDFFF007FDFFD007FE000007FE004007FDFFE007FE001007FDFFF007FE000007FE000007FDFFD007FE001007FE004007FE000007FE001007FE005007FE005007FDFFE007FE000007FE005007FE005007FE003007FE003007FDFFF007FE003007FE006007FE003007FDFFF007FE001007FE001007FDFFD007FDFFE007FE003007FDFFE007FE000007FDFFD007FDFFE007FDFFF007FE003007FE001007FDFFE007FE002007FDFFD007FE001007FE003007FDFFC007FE002007FE006007FDFFE007FE005007FDFFE007FE002007FE006007FE001007FDFFF007FE004007FE004007FE005007FE005007FE002007FE000007FDFFD007FE002007FE001007FE006007FE003007FE006007FDFFE007FDFFE007FDFFE007FE000007FDFFC007FE001007FE006007FDFFD007FE004007FE000007FDFFC007FE006007FE002007FE005007FDFFD007FE005007FE006007FE006007FDFFD007FE002007FDFFF007FDFFE007FE005007FE003007FE006007FE004007FDFFE007FE000007FE001007FE003007FDFFF007FE000007FDFFD007FDFFD007FE005007FDFFF007FE003007FE000007FE003007FE004007FDFFD007FE000007FE001007FE001007FE005007FE005007FE000007FDFFE007FDFFD007FDFFE007FE003007FE000007FDFFF007FDFFD007FE004007FDFFD007FDFFD007FE003007FDFFC007FE005007FE006007FDFFF007FDFFC007FE004007FE002007FE006007FE006007FDFFC007FDFFE007FDFFC007FE003007FE003007FE005007FE004007FE006007FE000007FE003007FE000007FDFFE007FDFFC007FE004007FE002007FE002007FE004007FE004007FE001007FE005007FE004007FE004007FDFFD007FDFFE007FDFFD007FE005007FE000007FDFFC007FE000007FE001007FDFFE007FDFFD007FE006007FE001007FE002007FDFFD007FE004007FE001007FE000007FE001007FE006007FE005007FE006007FE002007FDFFD007FE002007FE004007FE002007FE003007FE002007FDFFF007FDFFD007FE001007FDFFC007FDFFC007FE004007FE002007FDFFE007FE001007FE005007FE002007FDFFD007FE001007FE000007FE005007FE004007FDFFD007FDFFF007FDFFE007FE005007FE001007FDFFD007FE005007FDFFE007FDFFF007FE005007FE005007FDFFD007FE002007FE003007FE003007FE005007FE003007FE000007FDFFC007FE005007FE006007FDFFE007FE005007FDFFC007FE002007FDFFD007FE005007FE004007FDFFC007FE005007FE001007FE006007FE004007FDFFF007FE003007FE005007FDFFC007FDFFC007FE005007FE006007FE004007FE000007FE006007FE005007FDFFD007FE004007FE000007FE000007FE003007FE000007FDFFE007FE001007FDFFD007FDFFC007FDFFD007FDFFD007FDFFE007FE000007FDFFE007FDFFE007FE001007FE001007FE002007FE005007FDFFE007FE004007FE000007FE002007FE004007FE002007FE006007FE003007FE006007FDFFC007FDFFD007FE003007FDFFD007FDFFC007FE002007FE002007FDFFC007FE000007FE002007FE001007FDFFC007FE001007FDFFC007FE000007FE000007FE002007FE006007FE003007FE003007FDFFD007FDFFD007FE002007FE001007FDFFD007FDFFC007FDFFF007FE005007FE003007FDFFE007FDFFC007FDFFE007FE006007FE000007FDFFC007FE002007FE006007FDFFC007FDFFD007FE000007FDFFC007FE006007FE000007FE006007FDFFC007FE006007FE003007FDFFD007FE003007FE005007FE004007FDFFF007FE005007FE003007FE002007FDFFD007FDFFE007FE001007FDFFF007FDFFF007FDFFC007FE006007FDFFD007FDFFC007FE005007FDFFD007FDFFC007FDFFE007FDFFD007FE000007FE003007FE002007FE005007FDFFE007FE001007FE000007FE001007FE003007FE002007FE002007FE000007FDFFF007FE005007FDFFF007FE002007FE000007FE001007FE003007FE002007FE001007FE003007FDFFC007FE002007FDFFC007FE006007FE001007FDFFF007FDFFC007FDFFC007FDFFD007FE004007FDFFC007FDFFE007FDFFF007FDFFC007FDFFD007FE004007FDFFC007FDFFD007FDFFC007FDFFD007FE001007FE006007FE000007FE004007FDFFF007FDFFC007FDFFD007FE001007FE000007FDFFC007FE002007FE002007FE001007FE005007FE001007FDFFC007FDFFE007FE005007FE003007FE002007FE004007FE000007FDFFD007FE001007FE006007FE001007FE000007FE002007FE000007FE000007FDFFC007FE005007FE004007FDFFF007FE002007FE000007FE003007FE005007FDFFC007FE000007FDFFC007FE002007FDFFC007FE003007FE003007FE001007FE006007FE000007FE003007FE003007FE006007FE004007FE002007FE002007FE003007FE005007FDFFF007FDFFD007FDFFF007FE004007FDFFF007FDFFD007FE001007FDFFD007FE006007FE006007FE006007FE000007FE002007FE005007FE002007FE001007FDFFF007FE006007FE003007FDFFE007FDFFF007FDFFC007FE005007FE002007FE000007FDFFF007FDFFD007FDFFF007FDFFE007FE005007FE002007FE001007FDFFE007FE005007FE004007FDFFD007FE006007FDFFC007FE000007FE001007FE001007FE002007FE000007FE003007FDFFD007FDFFC007FE005007FE001007FE000007FDFFD007FE006007FE004007FE006007FDFFD007FDFFE007FE004007FE002007FE003007FE004007FDFFE007FDFFD007FDFFC007FE001007FE003007FDFFD007FDFFF007FE001007FE000007FDFFD007FE003007FE005007FE005007FE001007FE001007FE000007FE006007FDFFC007FE006007FE005007FE006007FE006007FDFFF007FE004007FDFFC007FDFFF007FE005007FE006007FE005007FE004007FE006007FDFFD007FDFFC007FDFFD007FE002007FDFFF007FDFFF007FDFFE007FE002007FDFFC007FE001007FDFFF007FDFFD007FE004007FDFFF007FE005007FE005007FE006007FE006007FE003007FE002007FDFFC007FE000007FDFFF007FDFFD007FDFFD007FE000007FDFFE007FE003007FE003007FE001007FE001007FE004007FE001007FDFFD007FDFFC007FE004007FDFFD007FE005007FE005007FE004007FE006007FE000007FE002007FE002007FE002007FE002007FE004007FE000007FDFFF007FE000007FDFFC007FDFFE007FDFFC007FE006007FDFFD007FE001007FDFFF007FE002007FE001007FE002007FDFFE007FDFFF007FDFFC007FE002007FE002007FE001007FE005007FE003007FE001007FE006007FE000007FE000007FE002007FE003007FDFFC007FE006007FDFFE007FE006007FE004007FDFFE007FDFFF007FE004007FE004007FDFFF007FE005007FE006007FDFFE007FE004007FE004007FE002007FDFFC007FE006007FE002007FE004007FE005007FE001007FDFFE007FDFFF007FDFFF007FE004007FE000007FDFFE007FDFFE007FE005007FE003007FDFFE007FE006007FE006007FE005007FE004007FE004007FDFFF007FDFFD007FDFFC007FE004007FDFFF007FDFFC007FDFFD007FE006007FE000007FE006007FDFFC007FDFFD007FDFFF007FE003007FE000007FDFFC007FE005007FE004007FDFFE007FDFFD007FE005007FE004007FE006007FE002007FDFFD007FE001007FE006007FE002007FDFFF007FDFFE007FDFFF007FDFFE007FDFFC007FDFFF007FE005007FDFFF007FE000007FE000007FE003007FE006007FE005007FE004007FE002007FE006007FDFFD007FDFFF007FDFFE007FE003007FE005007FE004007FDFFC007FE003007FDFFD007FE001007FE005007FE003007FE001007FE005007FDFFF007FDFFD007FE006007FDFFD007FE006007FE006007FE000007FDFFF007FDFFE007FE002007FDFFF007FDFFE007FDFFD007FDFFF007FDFFD007FDFFE007FDFFF007FE000007FE000007FE004007FE004007FE003007FE001007FDFFC007FDFFF007FE003007FE003007FDFFE007FE005007FDFFE007FE004007FDFFD007FE000007FE006007FDFFD007FDFFD007FDFFF007FE006007FDFFE007FDFFD007FE005007FDFFE007FDFFF007FE005007FE003007FE003007FE004007FE000007FE005007FDFFD007FDFFE007FE004007FDFFD007FE004007FE001007FE003007FE002007FE006007FDFFC007FE004007FDFFE007FDFFE007FDFFE007FE000007FE005007FDFFD007FE004007FE000007FDFFC007FDFFF007FDFFF007FE003007FE003007FDFFD007FDFFF007FE004007FE004007FE000007FE000007FE000007FE004007FDFFF007FDFFE007FE006007FDFFE007FE003007FDFFC007FE004007FE004007FE004007FE001007FE004007FDFFD007FE000007FE002007FE005007FDFFF007FE005007FDFFF007FDFFE007FE004007FDFFE007FE001007FE003007FDFFD007FDFFE007FDFFF007FDFFD007FE005007FE001007FE003007FDFFC007FE004007FE001007FE004007FE003007FE001007FE003007FDFFF007FE004007FE000007FE006007FDFFC007FDFFF007FDFFD007FE001007FE002007FE000007FE006007FE000007FE006007FDFFC007FDFFC007FE005007FDFFC007FDFFF007FDFFF007FDFFD007FE004007FE000007FE004007FE001007FDFFE007FE001 +y = 0080558D0085316B0079C0BA0084B0FB00858B61008707F300838437007FA87400821CD900809CAC007925360080C5B10083EAB8007F49960083A84B00864F3C0078CDEA00800377008381F0008482D30084CD63007F1094007F19900080C0910086F52F00800D97007BB8B4007DD895007A03E3007910870081C504008289FE007A709A007E0B68007A746C0082CE2D00810E82007A80540078BF5C007EAA2F007A90F100836D63007F83F6007A68E60083DA25007DFAF60078820F00842009007E19050082C0BE007AB0D20085B33C00796AEA007B9082007B36C8007A040B007AF92100791B80008429ED007B181C0087DDDC0080E7ED007AC9B4007AC35D0083ED8F008259A0007ED0DA007DE62800833CAA00789AE70078975E008233BC00873FE40087A4F2007AFEC4007CC884007E11FC00784842007B06960087C821007DB49900821D90007F53AE0083C0400083A391007816270086F9C90083D120007B16FC0078BB31008628490082FEB10082E91E007B8663007BBA5B0086A4B8008155B00086A2B2007A5044007C584700873871008440BD007CE82A00823720007FF5C2007B63A30081521A007B01B3007C25C50084343C0086EED900795E5D007BD8160081BBC4007C76C70078FC0C007EB2CC0085B6A700789674008736DF00792F0D0081C8AB00840E23007DC60000814F260080A1D4007A8680007A16A700862DBA007A385D00831B670080ADF5007F1A40007D9E94007B011C007D4D910081A63C0080DA1F00790C720080314200869104007E5750007E4A870080E92D00831A260087CEA0007FB31D00866AA3007C60D500798F11007FBE690087BB27007E74C0007DB59B008706F20081AB92008723AA007D96BC007AE5350078B4C4007EA2D70078E299007B698C00834C220085A02A00783C0000858D62007A34040086300C00836380007B4D6D007BC6A3007CFEE8007CBAC0008608C40080D93400840291008306BE0082F231007AEB94007C3E32007DFFB60079A02D008682810087B9540080299000874C9B007CF6E70080C6FB0087573A0084B5D200815E840081D77F0083E32A00839DB1007BC38A007F610000844AA70084F5AB007CE5090087261B00821B720085023E00836F0B007CE4B500847DAA008314B9007DC829007D5A670082C861007893CC008771CB008037700078701B007AF8E1007DF75C007E90BB007A0EEC0078C9C5007B3906007C911300857B8A00826F2A007C114A0078E3790081B1D9007C0137007EAE7900841DCF0086ECD600795B16007BBB76007EA588007D5E710086596100797A9800789AB5008643570078462F0087AB48007DE58D007D123F007C5EA0007E9B9200804851008269EF007EA597007D9A98007DF8210084151500844BFB0086854A007B12D200799C270080755900837786007B38A400793F0B007DF2F80078FE14008015D200834F49007F28530079767A00833E170083C17F00810642007D9C8C008118470082CA62007C5918007B421F0082D31D00828E110082841700809D86007F7F5E0080812D007A9AB30082B7D4007FE96C0084726D007B138000878016007A6086007BB041007BFB45007EDDD50078C0800082774B008647DF0082A31C007ED1AA007BD8FA0086F113008088D3007CC7B9007AF3BE007B56120078C5CE0082D0B9007D13C6007E602A008065980079116600844C16007E83C5007E36340085A1680086E9D50078AD37007AC8A70082AFDB00796AA3007BDF6D0083F7C9007F5DE90081059D008687070086545A00815ABC007E88D6007D547200849E4F007C9440007E8D910083AF740079611400804AD0008527230087266F008641A700791A970079D3A9008673DE0080BF8A0085358D008636530085259700842161007BF7290082D3FC0085023B0083D9F500858CF8008356C5007A45830078F7BA0083738D0078A23D00865BCC007A9D440087B9E4007B99140081096900852C71007D1ADA0080C30D007F21CA0081863A007FFAED007D7DED007EB328007A15830080EDC80087C15C0087CF680082AF430083EFD3007D01A30082BD94007B848300830BC6007FD15A0078B7FE00865951007D7A5B0086DA130080B7940086ED8A008197620085AFC5007CC9F9007B9A470087937700829DEC0081CDC60084E4FE007F486E0084EA080082DE98007D32240081D54200804B1E007E15D20079788B0081A2D70085149D00791507008346810086AD5A00816A4A00796FDC0084E857007D28A7007F08D5007C4D4F0078303A007C05AF007F9154007FFFF30081E0EF008442B4008707B7007FEB14007D24A5007F295C007A9E94007E51B90084626A007BA9D2007D527A007A6DE8007E9CCD00822DA8007836080081B58B008765C5008744650087295900780D0700793A1A0079D6200080DF4F007AA40B0079D62B0080B59B008589BB008112520083FF5A0078E08A00878B17008024BF0082FFE70078F5D80084DCAB007C19230079AC8C007E2916007BAA160078D8F5007FF7D400821D13007926C3007E94D400851698007CE0C700781749007FEB44007ED299007FFFBB0085CCB80082B1B400813A1500843FC80081A52A007F3BE9007F16D7007E380F0085845B007DCC8B0086B6E3007CAD47007EE32F007D78CA007BF4A40087B8AF007D63390078E6B5007EFD650083018C00853CD20082B0C9007B7872007EFF44007A0528007DCACB0086065E007C8614007920250084212A007E9B53007E69640081164B008556990084EEB1007E9499007ACC10008737A60082E5E5007CF754008244620084679600786632007FC4F800831EB6007B1FDA0079EF490078352C007A003E007C27B0008181A4007C81BC0082B3F4007FD2EF0083514A0078FE6D0082532D008188FE0081D2B6007E40F70085B8D500813049007FA6D60084E561007F6098007F8C89007A785B008684E90081746F0080EC87007C91FC0083F997007C3C4C007FE163007B94F0008475BB0083F8E3007BE20A007F548E00835ACA007C1B930080B324007BA75A007BAEAA00834BA0007CB8C80080571B007CB6BE0085682F00819DBD0087D4A20087B79B0087265E0083A5950087B920007C4F5A00805987007F8CF3007C4BB10081B5F90080C547007A072600812D140080D8C10084A9F40085392F007E84A1007D1CBB007AA4A80083AF23007C8768007D9E6F0079BFE30078451B007F28CD0079D8CD007B93730087B9AA00849A7F0084846D0083443A00842F7D00871E20007C9DD2007C6001007AD188007CFA5100819723008460B6007833C4007D34CD007DE83E008420AD007FB838008668D6007F4858007F26C10084DEAC00853439007E2BB1007877160084668E007DEB3500867A0D00843EE6007B7CA9007BD26D007916060082726200818E04007C5EDD00798D79007DE4160085F4FE008358E6007BB56400805F3B008479C6007BCF2C00824C98008034620081F973007E870C007CFADB007C822D00803D20007D4F12007CD7E6007CD3A20077FEEC0081A1890084DEC3008435B3007FA13400786F000083DEB800806D000081FD32007AC113007D24990080449B007F12360084D6A9007978740078041A007D74E1007F61710079F09F0083E4CE00811D280084E735007A54830086882100846962008431BC007D898A008507510079EAE9007DAD0E0078A7EE00835A0D007DC3F0007E077A0078F005007C990700869443007E124F0081C71C007E8B57007CDBDB007F282D0081A0E600817E95008384B00087424000873E020084D7CC0085A93D00804C95008238AA007D4247007A9376007AA66E007BADD8007FDD09007B65DA0081FED7007FBA17007EA0810081677D0084531D00835F9E007DEF960081F2C6007F4B250078D5F9007822EF0077EB2F007CAB1D007EA404007BB1DE007C4BC2007F2F000085F24A007CEB3E008723540083006300832A5B0080639D007F206F00843F710078CABC007AEB6C00783F9700796747007A52F000781F48007FBD8000857B7A008062810083369C007AB5AE007F6AD7008283EC0080E21600838491007E4EF1008183B5007EA2A000792D82007F34A80079B1870080A99C0084919C00805C710081036D0081DA1E007F2181007E72AE007D2EEA007AEE3E00788D94008357BC0080A0810086588A00856C2900816690007C078D00832E6D008409A0007F37DB00826D02007E924A0086DC72007F3744007DAE40007F6971007B70200084418300855F090086B0D20084F7CF007A3197007BC84B007C36180083878B007895EF007A60550081F2C400848DC200851F2C008378FF00867F23007B5ABC007A38D90078BE1B00801DDD007FAF77007975150081AA6E0080C61100845D0E007C74D1007D54EA007FF5060078D0AE007C0A680077F8CE0078976100795270008429B20085BDCA0081E7170082BC73007933C20084730C007D5125007F329C00817C69007CD0D0008432CA007A49E3007D4FF7007E81EE008403BD00849B5F0081A6B5007C9A48007B706B00837203007999C900785340007D715F00799D3A00802591007B86D30078E4350081D20B007934CA00789E58007B430C007FDDC30082692B0078BABB00793542007CC2EF00816B41007ED8180077FBA6007D6D8B007EE9530081EBF90083EECD008132BA008666D3008516CD007EDDFF0086DC75007B4A05007A148A007CD43500793AF8007B3C4D007FCC790078A2B4007BD38B0083210E007BD7DF00818FDA00849C8A00826059007923CB007B00ED00875DC6007F64DC007D5AD70084D609007C2CA50082766300861364007E31CD00781301007A33F0007A508B00851A26007E82BA0087CD600079513500784AF70080DB8B00878B130079246A007DEBA8008068F9007F20B2007D9CC300847663007BCF5B007F5842007F51CD008202A20085487D0082EAEE0086D833007BA3B9008519FE00836AB9007A30A5007AD6DD0078F2D1007B6F45007F7D420084AD18007FD21500797E6C0080F9F20081E7C6007FECCE007C968C0084B7C9007BAA3A008323D30082401B00858FEE0082359700838FE5007DBF00007EEEF90085443A0086AE6A0086875B0086F227007CBF070081A222008781B9007BBF5B007F43F100819D60007E15D20086012700848B2C008192D6007EB5FA00847CC70080DD6200798F4000816CD6007DE6200083CBEB0086A99C007E990D007FA4AC008129EB00864A5F0083AF1C007A6B8C0082FCA8007C43C400845C7D0081E1D9007E45D10082ED74007BB8DA00859E6D007EBC20007E070B00838620007B2BF3008479DA0079233500811585007BF37E007825C50078F5F20084EDE00080F9B5007EA50D0087334E0087C13E007FD7FF007FD3500087582B008597FB0077F4F000781A140086DF56007AF91000866583007B40ED007D915F007F48CB008057C5008532430078D35F0079348300835489007B4FF00084F3E00079CBA1007BF42000796B26007C32CD00872F60007801AE007E01A80079C3A5007883D000864F290080FCEA007B898E00827603007FA957007ABB590078842E0082517B007C9B45007F4B2B008340BC008185D900858932007A912D007CC46A007AC052008050F400816801008252F3007DF4000081D598007B0DEC00846A9D0083E138007F14F50078CE7F0083FF2C0083370800801B33008130DB007D28F10085358F007CA2930080F77D0085F95200801C95 +w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c = 00000000007FE0000000000000000001000000000000000000000000007FE000000000000000000000000000007FE00000000000007FE00000000000000000000000000100000000007FE00000000000007FE00000000001000000000000000000000000000000000000000000000000000000000000000100000000007FE00000000000000000000000000000000000000000000000000000000001000000000000000000000000007FE0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007FE0000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000010000000000000000007FE00000000000000000000000000000000000007FE000007FE00000000000000000000000000000000000000000000000000000000000007FE0000000000000000000007FE00000000000007FE0000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000007FE0000000000000000000000000000000000000000000007FE00000000000000000000000000000000000000000000000000000000001000000010000000000000000000000010000000000000000000000010000000000000000000000000000000000000000007FE00000000000007FE0000000000000000000007FE000000000010000000000000000000000000000000000000001000000010000000000000000000000010000000000000000007FE000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000007FE0000000000000000000000000000000000000000000000000000000000100000000000000000000000000000001007FE0000000000000000000007FE00000000000000000000000000100000001000000000000000000000000007FE000000000000000000000000000000000000000000000000000007FE00000000001000000000000000000000001007FE000007FE000000000000000000000000000000000010000000000000000007FE00000000000000000000000000000000000007FE00000000001000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007FE000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000007FE0000000000100000000 +count = 6 +seed = D8C4510916D61E3F2109E7B26DDDF156A45576A7A104986B55C0ABECAAD5864D80F0179F71B05D54A2667C60334A29E0B9CF1842D8593CC2DAE6F03935579B4535BA6B633CF5459CBAAD33967A3D1BF3 +mat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s = 007FE001007FE002007FE002007FE001007FE002007FE005007FE000007FE002007FDFFF007FE004007FDFFC007FE006007FE003007FDFFC007FE006007FDFFE007FE003007FDFFD007FE002007FE001007FDFFF007FDFFC007FDFFF007FE001007FE005007FE001007FE000007FE000007FE001007FDFFD007FE000007FE005007FDFFC007FE001007FE006007FE004007FDFFF007FE000007FDFFD007FE006007FE002007FE003007FDFFC007FDFFC007FE003007FE005007FE004007FE000007FE005007FDFFE007FE000007FE001007FE003007FE001007FE006007FE001007FE006007FDFFD007FDFFD007FE000007FE002007FE001007FE002007FDFFD007FE002007FE001007FE004007FDFFD007FE000007FDFFF007FE005007FDFFE007FE000007FE000007FE003007FDFFD007FE001007FE005007FDFFD007FE006007FE002007FE003007FE004007FE002007FDFFF007FDFFE007FE004007FE001007FE004007FDFFC007FE006007FDFFC007FE003007FDFFD007FDFFC007FE000007FE006007FE000007FE005007FDFFF007FDFFF007FDFFC007FE001007FDFFF007FE002007FDFFE007FE006007FE003007FE006007FE006007FE002007FE004007FE001007FE002007FE002007FE006007FE004007FE003007FDFFE007FDFFE007FDFFE007FDFFC007FE000007FDFFC007FDFFF007FDFFF007FE003007FDFFE007FE005007FE004007FE003007FE002007FE000007FDFFC007FE000007FDFFC007FE004007FE002007FE005007FDFFF007FE006007FE006007FE002007FE006007FDFFF007FDFFD007FE005007FDFFF007FE004007FDFFC007FE006007FDFFD007FDFFD007FE005007FE001007FE003007FE002007FDFFE007FDFFF007FE006007FE000007FE006007FE006007FDFFC007FE006007FDFFD007FE005007FE001007FE001007FE002007FE002007FE005007FE003007FDFFC007FDFFF007FE005007FDFFD007FE001007FDFFF007FDFFF007FDFFF007FE004007FDFFE007FE006007FE005007FE000007FDFFE007FDFFC007FE003007FE003007FE001007FE006007FE000007FDFFE007FE006007FDFFF007FE002007FE004007FDFFF007FE004007FE005007FE004007FDFFF007FDFFC007FE000007FDFFC007FE003007FE006007FE004007FDFFD007FE004007FE004007FDFFC007FDFFF007FE006007FDFFC007FE004007FE002007FE003007FE006007FDFFD007FE001007FE002007FDFFD007FE004007FE005007FE005007FE006007FE006007FE000007FE000007FE005007FE002007FDFFF007FE000007FE006007FE005007FE002007FE005007FE005007FE005007FDFFD007FDFFE007FE000007FE005007FE004007FE005007FDFFC007FDFFF007FE006007FE000007FE004007FDFFE007FE005007FDFFF007FE004007FE005007FDFFD007FDFFE007FE005007FDFFD007FDFFE007FDFFE007FE000007FDFFE007FDFFE007FDFFD007FDFFD007FE003007FDFFF007FE000007FE001007FDFFE007FE004007FDFFE007FE006007FE005007FE000007FE002007FE003007FE005007FE004007FE005007FE000007FDFFD007FDFFF007FE002007FE004007FE001007FDFFC007FE006007FE006007FE004007FDFFD007FE006007FDFFD007FE002007FE001007FDFFE007FE000007FE005007FDFFF007FE001007FE004007FE000007FE003007FDFFD007FDFFE007FE006007FDFFD007FDFFF007FDFFE007FE001007FE001007FE000007FE006007FE006007FE001007FDFFE007FE003007FE001007FE005007FE003007FE001007FDFFD007FE006007FE002007FE006007FE001007FE005007FE005007FE002007FDFFC007FDFFC007FE005007FE006007FDFFC007FDFFC007FE006007FE005007FE000007FDFFD007FE005007FE002007FE001007FE006007FDFFF007FE001007FE006007FE002007FDFFC007FE005007FE001007FE001007FE004007FE006007FE002007FE005007FE001007FE001007FE002007FE002007FDFFE007FDFFF007FDFFC007FE005007FDFFE007FE003007FE000007FE001007FE003007FE003007FE001007FE004007FE003007FDFFC007FE003007FE006007FE002007FE004007FE000007FE001007FDFFE007FDFFF007FE002007FE003007FDFFE007FE006007FDFFC007FE006007FE003007FE004007FDFFF007FE002007FDFFD007FE006007FDFFE007FE003007FE003007FDFFC007FE002007FE002007FE000007FE003007FDFFE007FE005007FE001007FE005007FDFFF007FE000007FDFFF007FE002007FDFFF007FDFFE007FDFFF007FDFFF007FDFFF007FE004007FE001007FDFFE007FE003007FE006007FE000007FE003007FE002007FDFFC007FE006007FE005007FE003007FE003007FE000007FE000007FDFFF007FDFFF007FDFFD007FDFFC007FE004007FDFFD007FDFFD007FE001007FE004007FE001007FE003007FE002007FE004007FE001007FE004007FE004007FDFFD007FDFFD007FE002007FE003007FE001007FDFFC007FDFFD007FE000007FE004007FE005007FE002007FE001007FDFFC007FE000007FE005007FE006007FDFFF007FDFFE007FDFFC007FE002007FE001007FE002007FDFFE007FE003007FE000007FDFFF007FDFFC007FE004007FDFFC007FE003007FDFFE007FE004007FDFFF007FDFFF007FDFFE007FDFFF007FDFFD007FDFFF007FE002007FDFFE007FE000007FDFFE007FDFFD007FE004007FE000007FDFFC007FE005007FE000007FE001007FE006007FE002007FE005007FE006007FDFFF007FDFFC007FE004007FE005007FE000007FE003007FDFFC007FE004007FDFFF007FE005007FE001007FE005007FE002007FE001007FDFFF007FE001007FDFFD007FE002007FE003007FDFFC007FE002007FE001007FE004007FE003007FE005007FDFFF007FE000007FE000007FDFFF007FE000007FE001007FE000007FE001007FE003007FE006007FE003007FDFFC007FDFFE007FE006007FDFFD007FE005007FE004007FE002007FDFFF007FDFFF007FE002007FDFFC007FE000007FE005007FDFFD007FE001007FDFFE007FE002007FDFFD007FE005007FE005007FDFFE007FE004007FE003007FDFFF007FE004007FDFFC007FE004007FE002007FE002007FE005007FE004007FDFFF007FE005007FE000007FDFFD007FE001007FE002007FDFFE007FE005007FE006007FE000007FDFFE007FDFFE007FDFFE007FDFFF007FE000007FDFFC007FDFFF007FDFFD007FE003007FE002007FE005007FE003007FE001007FE000007FE002007FE004007FE002007FE000007FE001007FE006007FE003007FDFFE007FE003007FDFFD007FDFFC007FE005007FDFFE007FDFFD007FDFFE007FE006007FE002007FE003007FE000007FE005007FE001007FE005007FDFFE007FE006007FDFFE007FE002007FDFFC007FDFFC007FDFFF007FE005007FDFFE007FE006007FDFFC007FE005007FE001007FDFFC007FE002007FE002007FE002007FE003007FDFFE007FDFFE007FDFFD007FE004007FE000007FE002007FDFFF007FDFFF007FE000007FE003007FDFFE007FDFFC007FDFFC007FE004007FE006007FE004007FE002007FDFFD007FDFFF007FDFFF007FDFFC007FE003007FE004007FE004007FDFFF007FDFFE007FE006007FDFFE007FE003007FE006007FDFFD007FDFFC007FE002007FE004007FDFFF007FE002007FE003007FDFFD007FE003007FE002007FE000007FE005007FE003007FDFFE007FE003007FDFFE007FE003007FE001007FDFFC007FDFFC007FE000007FE005007FE001007FE004007FDFFF007FE002007FE006007FDFFC007FDFFC007FDFFD007FE000007FE004007FE003007FE005007FDFFF007FDFFC007FE001007FDFFF007FE001007FDFFC007FE003007FE003007FDFFC007FE005007FE000007FE003007FE006007FDFFE007FDFFD007FE004007FDFFD007FE000007FE003007FDFFF007FE000007FE002007FDFFC007FDFFF007FDFFC007FE003007FE006007FE003007FE002007FDFFE007FE006007FDFFE007FE002007FE001007FE001007FDFFE007FE000007FE006007FE006007FDFFC007FE003007FE002007FDFFE007FE005007FE005007FE003007FE005007FE005007FDFFF007FDFFC007FDFFF007FE006007FE001007FDFFE007FE000007FE003007FE003007FE005007FE003007FE003007FE002007FE003007FDFFC007FDFFD007FE003007FE006007FDFFC007FE006007FE006007FE005007FDFFD007FE000007FE005007FE002007FDFFE007FE005007FDFFF007FE001007FE001007FDFFC007FE000007FDFFF007FE005007FE001007FE006007FE001007FDFFE007FDFFE007FDFFE007FE000007FE002007FE002007FE000007FDFFD007FE005007FE001007FDFFF007FE006007FE001007FE002007FE000007FE003007FE003007FDFFE007FE002007FDFFF007FE003007FDFFE007FE003007FDFFC007FE005007FE001007FE001007FE006007FE004007FE006007FE003007FE004007FDFFF007FDFFD007FE003007FDFFC007FE005007FE005007FDFFF007FE000007FE002007FE001007FE006007FDFFD007FDFFF007FE004007FE006007FDFFF007FDFFF007FE000007FE005007FE001007FE006007FE002007FDFFE007FDFFF007FE005007FDFFF007FE003007FE002007FE004007FE001007FDFFD007FE006007FDFFC007FDFFD007FDFFE007FE000007FE002007FE000007FE002007FDFFE007FDFFF007FDFFF007FE005007FE004007FDFFF007FE002007FE005007FDFFE007FE002007FDFFF007FE000007FDFFD007FDFFD007FE004007FDFFC007FDFFD007FE000007FDFFE007FE000007FDFFD007FDFFC007FE003007FE001007FDFFE007FE003007FE004007FDFFE007FDFFE007FE006007FE000007FE002007FE006007FE003007FDFFC007FE004007FDFFE007FE002007FE000007FDFFE007FDFFD007FE002007FDFFC007FDFFF007FDFFD007FE001007FDFFD007FE002007FE004007FE005007FDFFF007FE001007FE003007FE002007FDFFF007FE000007FE003007FE005007FE004007FE001007FE005007FE000007FE006007FE002007FE003007FDFFE007FE000007FE005007FE005007FE001007FE003007FE004007FE006007FDFFE007FDFFC007FDFFC007FE000007FE005007FDFFC007FE001007FDFFE007FE003007FE006007FE000007FDFFE007FE002007FE004007FE006007FDFFC007FE002007FDFFC007FDFFC007FE004007FE003007FE006007FDFFD007FDFFE007FE000007FDFFD007FE001007FE003007FE006007FDFFE007FE000007FDFFD007FDFFF007FE001007FDFFC007FE006007FDFFE007FDFFE007FE006007FE000007FE000007FDFFD007FDFFE007FE001007FDFFF007FE002007FDFFE007FE000007FE000007FDFFD007FDFFC007FDFFC007FE005007FE006007FE002007FE003007FDFFD007FE003007FE000007FE005007FE000007FE004007FE004007FDFFD007FDFFC007FE001007FDFFF007FE005007FDFFF007FDFFF007FE003007FDFFC007FE000007FE005007FDFFE007FDFFC007FDFFF007FE003007FDFFD007FE002007FE002007FE005007FE005007FDFFF007FE001007FE000007FDFFF007FE003007FE002007FDFFE007FE003007FE004007FE003007FE003007FDFFF007FDFFC007FE001007FE001 +y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w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c = 000000000000000000000000000000000000000000000000007FE0000000000000000000000000010000000000000000000000000000000000000000007FE00000000000000000000000000000000000000000000000000000000001000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000100000000000000000000000000000000000000000000000100000000000000000000000000000000007FE0000000000000000001000000000000000100000001000000000000000100000000007FE000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000007FE00000000000000000000000000100000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000010000000100000000000000000000000000000000007FE000000000000000000000000000000000010000000000000001000000000000000000000000000000000000000000000000007FE000000000000000000100000000000000000000000000000000000000000000000000000001007FE0000000000000000000000000000000000000000000007FE0000000000000000000000000000000000100000000000000000000000000000001000000000000000000000000000000010000000000000000007FE000000000000000000000000000000000010000000000000000000000010000000000000000000000000000000000000000000000000000000000000000007FE00000000000007FE00000000000007FE000000000000000000000000000000000000000000100000000000000000000000000000000007FE0000000000000000000000000010000000000000000007FE000000000000000000000000000007FE0000000000000000000000000000000000000000000007FE00000000000000000000000000100000000000000000000000000000000000000000000000000000001007FE000000000000000000100000000000000000000000000000000007FE00000000000000000000000000000000001000000000000000000000001000000000000000000000000007FE00000000000000000000000000000000000000000000000000000000000007FE0000000000000000000000000000000000000000000007FE00000000000000000010000000000000000007FE0000000000000000000000000000000000000000001000000000000000000000000000000010000000000000000007FE000007FE0000000000000000000000000000000000000000000007FE000 +count = 7 +seed = A2F78D3CBD3BDF1D1C344C9D374687B4B48FCD08BC07D4B8605DC1A1F7F387D2BF40CF6D95B1764B50C4B34AD84B4225C6B4174495E3DA5D17F79E829A5C13A7366E580A9B0107540C5AC5221293881E +mat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s = 007FDFFF007FE003007FE000007FE001007FE003007FE004007FE006007FDFFC007FDFFF007FE004007FE006007FE002007FE000007FE000007FE004007FE004007FDFFF007FE002007FE004007FE002007FDFFE007FE000007FDFFE007FE003007FDFFC007FDFFD007FE003007FE002007FE000007FDFFE007FE000007FE006007FE000007FE004007FE005007FE000007FE006007FE000007FDFFE007FE005007FE003007FE005007FE003007FE006007FE002007FDFFC007FE001007FE001007FE005007FE003007FDFFD007FDFFC007FDFFE007FE002007FE006007FE005007FDFFE007FDFFC007FE003007FDFFE007FE002007FDFFE007FE002007FDFFC007FDFFD007FE005007FE003007FE001007FE004007FE001007FDFFD007FE001007FE002007FE005007FE005007FDFFE007FE003007FE001007FE005007FDFFC007FDFFE007FE004007FE005007FE002007FDFFF007FDFFF007FE006007FE006007FE005007FE004007FDFFF007FDFFE007FDFFF007FE003007FE006007FE005007FE006007FDFFF007FE001007FE002007FE003007FDFFD007FE002007FE004007FDFFF007FDFFC007FDFFD007FE001007FE002007FE001007FDFFD007FE002007FE005007FDFFC007FE005007FDFFC007FE004007FE001007FE005007FE000007FE003007FDFFE007FE002007FDFFF007FE002007FDFFC007FE003007FDFFD007FE000007FDFFE007FE003007FE005007FDFFC007FDFFF007FE000007FE002007FDFFC007FDFFE007FE004007FDFFE007FE000007FE003007FE002007FDFFF007FE001007FDFFF007FDFFD007FDFFF007FDFFD007FDFFD007FE000007FE000007FDFFF007FDFFF007FE003007FE005007FDFFF007FDFFC007FDFFD007FDFFC007FE001007FE003007FE000007FE004007FE003007FE005007FE003007FE004007FE005007FDFFD007FE006007FE005007FE000007FE003007FDFFF007FE006007FE002007FE002007FE004007FDFFF007FE001007FDFFC007FE005007FE001007FDFFD007FE006007FE001007FE004007FE004007FE005007FE003007FDFFE007FE000007FE005007FE002007FDFFD007FDFFD007FDFFE007FE002007FDFFD007FE003007FE005007FDFFE007FE003007FDFFF007FDFFC007FE000007FDFFE007FE006007FDFFD007FE003007FDFFF007FDFFE007FDFFC007FDFFF007FE005007FDFFC007FE005007FDFFC007FE005007FDFFD007FDFFF007FDFFC007FE000007FE005007FDFFF007FE000007FDFFE007FDFFF007FE002007FE001007FE005007FE003007FDFFF007FE005007FDFFD007FDFFF007FE003007FE006007FE006007FDFFE007FDFFC007FDFFD007FE006007FE003007FDFFF007FE003007FE003007FDFFF007FE000007FDFFE007FE002007FE000007FDFFC007FDFFF007FDFFD007FDFFC007FE000007FE003007FE000007FE001007FE004007FDFFE007FE001007FE004007FE004007FE006007FE000007FDFFC007FE001007FDFFF007FE006007FDFFC007FE002007FE001007FE000007FE003007FDFFE007FE006007FE001007FDFFC007FDFFF007FE006007FDFFC007FE001007FE006007FE004007FE000007FE003007FDFFD007FE001007FE005007FDFFC007FDFFD007FE006007FDFFF007FDFFF007FE000007FE001007FE003007FE000007FE005007FDFFC007FE002007FE003007FDFFD007FE001007FE004007FE003007FDFFE007FDFFD007FE002007FE005007FDFFE007FDFFF007FE005007FE002007FE003007FDFFC007FE006007FDFFD007FDFFE007FDFFD007FE001007FE006007FE005007FDFFF007FE001007FDFFD007FDFFD007FE002007FE000007FE006007FE004007FDFFF007FDFFE007FE004007FDFFF007FE005007FDFFD007FE002007FDFFF007FE004007FDFFE007FE003007FDFFF007FE001007FE002007FDFFD007FDFFD007FDFFC007FDFFE007FDFFD007FDFFE007FDFFE007FDFFD007FE003007FE004007FE000007FDFFF007FDFFF007FE002007FE002007FE001007FE000007FE000007FE001007FE001007FDFFD007FE001007FDFFC007FE002007FE006007FDFFE007FDFFD007FE001007FE005007FE000007FE004007FE003007FE005007FE005007FE005007FE005007FE004007FE005007FE005007FE002007FDFFF007FE003007FE004007FDFFE007FE005007FE006007FDFFE007FE005007FE003007FE001007FE006007FE000007FE001007FE005007FE006007FE003007FDFFC007FE006007FE000007FE000007FE004007FE005007FE006007FE003007FE006007FDFFE007FDFFD007FE006007FDFFD007FDFFE007FE003007FE006007FE000007FE003007FE001007FE004007FDFFC007FDFFD007FE001007FE002007FE005007FE002007FE006007FE000007FDFFD007FE001007FDFFC007FDFFF007FE001007FDFFF007FE001007FDFFF007FDFFE007FDFFF007FDFFF007FE000007FE003007FDFFC007FDFFD007FE001007FE003007FE000007FE006007FE002007FE004007FE003007FE000007FE001007FDFFF007FE000007FE005007FDFFE007FE006007FDFFD007FE003007FE004007FE006007FDFFE007FE001007FE004007FDFFE007FDFFE007FDFFC007FE000007FDFFC007FE004007FE002007FDFFD007FE002007FE006007FE002007FE000007FE006007FDFFF007FE002007FE000007FDFFC007FE003007FE006007FDFFC007FE004007FDFFF007FDFFF007FE000007FE000007FE001007FE004007FDFFC007FE003007FDFFD007FE004007FE004007FDFFE007FE001007FE005007FE005007FDFFF007FE006007FE004007FE004007FE005007FE000007FDFFC007FE004007FE006007FDFFF007FDFFD007FDFFE007FE004007FE004007FDFFE007FDFFE007FE002007FDFFD007FE004007FE001007FDFFD007FDFFC007FE000007FE005007FE006007FDFFF007FE003007FE003007FE001007FDFFF007FE006007FE004007FDFFC007FDFFF007FE001007FE002007FDFFD007FDFFD007FE003007FE004007FE004007FE001007FE006007FE004007FE005007FDFFE007FE004007FDFFD007FE002007FDFFD007FDFFF007FE004007FE003007FE000007FDFFD007FDFFF007FE003007FE001007FE006007FE005007FDFFF007FDFFF007FDFFC007FDFFC007FE006007FE002007FDFFD007FDFFC007FDFFD007FDFFC007FE004007FE005007FDFFD007FDFFD007FDFFD007FE000007FDFFD007FDFFD007FDFFD007FDFFE007FDFFC007FDFFF007FE000007FDFFF007FDFFC007FE005007FE004007FE002007FE002007FE002007FDFFC007FDFFD007FDFFC007FE005007FE003007FE001007FE005007FE004007FDFFE007FDFFC007FDFFF007FE005007FE005007FDFFC007FE000007FE004007FE006007FE002007FE006007FE006007FDFFE007FE002007FDFFD007FE005007FE006007FE005007FE003007FE001007FE002007FE002007FE005007FE003007FDFFE007FE002007FE002007FDFFE007FE004007FDFFC007FE001007FE001007FE000007FE006007FDFFF007FE003007FE006007FDFFF007FE001007FE003007FDFFE007FDFFE007FE002007FDFFF007FE005007FE006007FDFFF007FE002007FE004007FE002007FDFFD007FDFFC007FE005007FE005007FDFFE007FDFFE007FE002007FDFFF007FE004007FE000007FDFFF007FE003007FDFFE007FE004007FE004007FE001007FE006007FE002007FE003007FE006007FDFFD007FE000007FE006007FE001007FE000007FE002007FE002007FDFFD007FDFFF007FE001007FE000007FE005007FE000007FDFFF007FE000007FE003007FDFFC007FE005007FE000007FE000007FDFFE007FDFFC007FE006007FDFFC007FE003007FE002007FDFFC007FE004007FE002007FE004007FE000007FDFFC007FE000007FDFFE007FDFFF007FE002007FE004007FE000007FE000007FE006007FE000007FE005007FE005007FDFFF007FE003007FE003007FE004007FDFFF007FE001007FE000007FE002007FE001007FE006007FDFFF007FDFFE007FE003007FE002007FDFFD007FE000007FE000007FE006007FE000007FE005007FDFFE007FDFFE007FDFFE007FDFFE007FE006007FE006007FE004007FE006007FE000007FE005007FDFFE007FE000007FDFFD007FE002007FE001007FE003007FE004007FE006007FDFFD007FE004007FE003007FE006007FE003007FE001007FE004007FE006007FE002007FE004007FE000007FE001007FE000007FE002007FE003007FE001007FE000007FE001007FDFFD007FE005007FE000007FE006007FE005007FDFFF007FDFFC007FDFFD007FDFFE007FE005007FE004007FE005007FDFFF007FE000007FDFFC007FDFFC007FE003007FE002007FE005007FDFFC007FE002007FE002007FE000007FE004007FE005007FE000007FE001007FE000007FDFFC007FDFFE007FE003007FDFFC007FDFFD007FDFFF007FE006007FDFFF007FDFFD007FDFFF007FE000007FE000007FDFFC007FE004007FE000007FDFFD007FDFFE007FE002007FE005007FE005007FDFFF007FDFFE007FE004007FE001007FDFFD007FDFFF007FE003007FE001007FE002007FE004007FE003007FDFFC007FE004007FE001007FE003007FDFFD007FDFFE007FE000007FE003007FDFFF007FE004007FE003007FE003007FDFFC007FE001007FE000007FDFFE007FE000007FE001007FDFFF007FE001007FDFFD007FE006007FE003007FE003007FE001007FE003007FE005007FDFFE007FE006007FE004007FE000007FDFFD007FE006007FDFFC007FE006007FDFFC007FE003007FDFFC007FDFFC007FE003007FE003007FE004007FE006007FE002007FDFFD007FDFFF007FDFFF007FE000007FE003007FDFFF007FE000007FDFFE007FDFFE007FDFFD007FE002007FE004007FDFFF007FDFFF007FE006007FE001007FDFFC007FDFFF007FE004007FE004007FE002007FE005007FDFFF007FE003007FE006007FE003007FDFFC007FE000007FE003007FE003007FDFFD007FE000007FDFFD007FDFFD007FDFFD007FE002007FE003007FDFFC007FDFFF007FDFFC007FE004007FDFFC007FDFFF007FE003007FE004007FDFFD007FDFFD007FDFFC007FE003007FE003007FE003007FE000007FDFFC007FDFFD007FE003007FDFFF007FE001007FDFFE007FDFFD007FE001007FE006007FE003007FE003007FDFFD007FE002007FE004007FE004007FE006007FE002007FE006007FE000007FE000007FDFFD007FE004007FE001007FE000007FDFFD007FDFFE007FE003007FE002007FE000007FE004007FE004007FE004007FDFFD007FE006007FE004007FE004007FE006007FE005007FE000007FE003007FE005007FE005007FE003007FDFFF007FDFFD007FE003007FE004007FDFFC007FE005007FDFFC007FDFFE007FE002007FDFFC007FDFFC007FDFFE007FE000007FE001007FDFFC007FE006007FE001007FE006007FDFFD007FE004007FE004007FDFFE007FE006007FDFFF007FE001007FE002007FE000007FE006007FDFFD007FE005007FE002007FDFFC007FE000007FE004007FDFFE007FDFFE007FE004007FDFFF007FE004007FE006007FE003007FE005007FDFFC007FE006007FDFFF007FE006007FE001007FDFFC007FE005007FE003007FDFFD007FDFFE007FDFFE007FE000007FDFFC +y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w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c = 007FE0000000000100000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000010000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000007FE0000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000100000000007FE0000000000000000000000000000000000000000000007FE00000000000007FE000000000010000000000000000007FE00000000000007FE00000000001000000000000000100000000007FE000000000010000000000000000007FE00000000001000000010000000100000000000000000000000000000000000000000000000000000001000000000000000100000000007FE0000000000000000000007FE0000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007FE0000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000007FE000007FE00000000000000000000000000000000001000000000000000000000001000000000000000000000000000000000000000000000000007FE000000000000000000000000001000000000000000000000000000000010000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007FE00000000000007FE00000000000007FE0000000000000000000000000000000000000000000007FE00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000100000001007FE000000000000000000000000000000000000000000000000000007FE00000000000000000000000000000000001000000000000000000000000007FE0000000000100000000007FE0000000000000000001000000000000000000000000007FE000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000007FE0000000000000000000000000000000000000000001007FE000 +count = 8 +seed = 02B60129C902FF57215E866427C4E6609CC830605E5B45341A48DBD50F5AA09748DEA18F40C8BB687422E864F930EB66CD535854B627C91377A70BF5CAB6E6A08F84A3343F79F0F32F01A63AC478D68C +mat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s = 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 +y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w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c = 000000000000000000000000000000000000000100000000007FE0000000000100000000000000000000000000000000000000010000000100000000007FE00000000001007FE0000000000000000000007FE000000000000000000000000001000000000000000000000001000000000000000000000000007FE0000000000000000000007FE000007FE000000000000000000000000001000000010000000000000000007FE0000000000000000000000000010000000000000000007FE000007FE000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000007FE00000000000007FE00000000000000000000000000000000000007FE000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000007FE000007FE00000000000000000010000000000000000000000000000000000000000007FE0000000000000000000000000000000000000000000000000000000000000000000007FE00000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000100000001007FE00000000000007FE000007FE00000000001000000000000000000000000000000010000000000000000000000010000000000000000007FE0000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000007FE0000000000000000000000000000000000100000000000000000000000000000000000000000000000000000001007FE000000000000000000000000000007FE00000000000000000000000000000000000000000000000000000000000000000000000000000000000007FE000000000000000000000000000000000000000000000000000007FE000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000007FE000000000000000000000000000007FE0000000000000000000000000000000000000000001007FE00000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000010000000000000000000000000000000000000000007FE00000000000000000000000000000000000007FE000000000000000000000000000007FE000000000000000000000000000000000000000000000000000007FE0000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000 +count = 9 +seed = 88712F0A3F45C3E2EDAD4079BAC2FF71AA85CE12D9E932819D6C4875279C5B02883352EEB30D8882AC6D1CE11E21217B4AFA22779F2128B1AB1149D4265FA5C6C3E273D088A8505DFDBF2901BA0F18F8 +mat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s = 007FDFFD007FE004007FDFFD007FE006007FE000007FE005007FE003007FDFFC007FDFFF007FDFFE007FE003007FE006007FE000007FE000007FE001007FDFFF007FE000007FDFFD007FE002007FDFFD007FE003007FDFFD007FE000007FE000007FDFFE007FDFFF007FE006007FE005007FE004007FDFFC007FDFFC007FDFFD007FDFFC007FE005007FE004007FE006007FE002007FE003007FE000007FDFFC007FE001007FE005007FE003007FE006007FE003007FE006007FE001007FDFFE007FDFFE007FE005007FDFFD007FE002007FE000007FDFFF007FE002007FDFFC007FE004007FE001007FE004007FDFFE007FDFFE007FE001007FE001007FE002007FE002007FE000007FE006007FE005007FE006007FDFFF007FE006007FE001007FDFFD007FE001007FE005007FE005007FDFFF007FDFFC007FE003007FE000007FE000007FDFFF007FDFFD007FDFFF007FE001007FDFFE007FDFFD007FDFFD007FE003007FE006007FE000007FE000007FE002007FE002007FE002007FDFFC007FDFFF007FE001007FE005007FE005007FE004007FDFFD007FDFFC007FDFFC007FE003007FDFFE007FE002007FDFFD007FDFFF007FE000007FDFFE007FE002007FE001007FDFFE007FDFFE007FDFFF007FDFFC007FE003007FDFFE007FDFFD007FE000007FDFFF007FE005007FDFFE007FE005007FE001007FDFFE007FE003007FE001007FDFFE007FE006007FE002007FE002007FE002007FDFFD007FE003007FE004007FDFFF007FE006007FE006007FE004007FDFFF007FDFFE007FE000007FE003007FE006007FE004007FE005007FDFFD007FDFFE007FE002007FDFFD007FE002007FE001007FE002007FE003007FE003007FE000007FE001007FE001007FE004007FE001007FDFFE007FDFFE007FE004007FE004007FE006007FE006007FE001007FE003007FE005007FE002007FE004007FDFFE007FDFFC007FDFFC007FE000007FE003007FE000007FE000007FDFFE007FDFFD007FE003007FE006007FE003007FE002007FDFFC007FE003007FDFFE007FE003007FE004007FE002007FE000007FE006007FE006007FE006007FE004007FE005007FDFFE007FDFFE007FE004007FDFFC007FDFFF007FE000007FDFFD007FDFFF007FE006007FE006007FDFFF007FDFFD007FDFFD007FDFFD007FE000007FE005007FE003007FDFFD007FE000007FE002007FDFFE007FDFFF007FDFFF007FE004007FDFFE007FE001007FE006007FE001007FE003007FE003007FE002007FE003007FE001007FE002007FDFFE007FE006007FE005007FDFFF007FDFFE007FE001007FDFFF007FDFFF007FE005007FDFFF007FE004007FE001007FE005007FDFFC007FE002007FE001007FE002007FE002007FDFFE007FDFFF007FE006007FDFFD007FE003007FE006007FDFFC007FDFFE007FDFFC007FE002007FE002007FE002007FE006007FDFFC007FDFFE007FE004007FE004007FE003007FE006007FDFFE007FDFFE007FDFFC007FDFFC007FE000007FDFFC007FDFFD007FDFFE007FDFFF007FE001007FDFFE007FE000007FDFFE007FDFFF007FE003007FE005007FDFFF007FE001007FDFFC007FE001007FDFFF007FE000007FE000007FE004007FE003007FE003007FDFFF007FDFFC007FE002007FDFFF007FDFFC007FE005007FDFFC007FDFFF007FE004007FE000007FE000007FE005007FDFFD007FE003007FDFFC007FE005007FE000007FE001007FE003007FDFFC007FE002007FDFFD007FDFFC007FE001007FDFFF007FDFFD007FE000007FDFFE007FDFFC007FE004007FE006007FDFFD007FE006007FE005007FE001007FE005007FE003007FE002007FE001007FDFFF007FE001007FE000007FE001007FE006007FE004007FDFFC007FE006007FE001007FE003007FDFFF007FDFFC007FE000007FE003007FE002007FE001007FDFFD007FDFFC007FDFFF007FE002007FDFFD007FE003007FDFFD007FDFFE007FE002007FE006007FE001007FDFFE007FDFFF007FE000007FDFFD007FE002007FE004007FE004007FE000007FDFFC007FE004007FE001007FE004007FE003007FE004007FDFFF007FE000007FE004007FE002007FE006007FDFFD007FE003007FE004007FDFFC007FE004007FDFFE007FDFFC007FDFFF007FE003007FDFFE007FDFFE007FDFFE007FE002007FE006007FDFFC007FE000007FDFFD007FE006007FE000007FDFFC007FE006007FE004007FE001007FE004007FDFFF007FDFFD007FE005007FDFFE007FDFFD007FE005007FE001007FDFFC007FE000007FE001007FE001007FE003007FE004007FE004007FE003007FE005007FDFFF007FE005007FDFFE007FDFFC007FDFFC007FDFFC007FE003007FDFFF007FDFFD007FE005007FE001007FE006007FE002007FE002007FE002007FDFFD007FE004007FE004007FDFFF007FDFFF007FE000007FDFFC007FDFFF007FE004007FDFFF007FDFFD007FE003007FE004007FE000007FE002007FE002007FE002007FE005007FE002007FDFFD007FDFFD007FE005007FE003007FDFFF007FE005007FE000007FE001007FE003007FDFFF007FDFFC007FDFFD007FE005007FE001007FE006007FE005007FE005007FE002007FE001007FE006007FE002007FDFFF007FE002007FDFFF007FE006007FE005007FE005007FE005007FE000007FE002007FDFFE007FDFFF007FE005007FE000007FE006007FDFFF007FE003007FE003007FDFFC007FE004007FE003007FDFFD007FDFFF007FE003007FE006007FE000007FE000007FDFFE007FDFFE007FE004007FE005007FE003007FE004007FE006007FE006007FE005007FE003007FDFFD007FE006007FE001007FDFFD007FDFFC007FE000007FE001007FE001007FDFFF007FE002007FDFFC007FDFFD007FE003007FE004007FE004007FE006007FE004007FE006007FE004007FE006007FE001007FE005007FE000007FDFFF007FE004007FE003007FDFFD007FE005007FDFFC007FDFFF007FDFFF007FE003007FE005007FDFFF007FE003007FE005007FE003007FE003007FE003007FE003007FE001007FDFFE007FE001007FDFFE007FE005007FE001007FDFFF007FDFFC007FE005007FDFFD007FE005007FDFFC007FE000007FE001007FDFFD007FE003007FDFFE007FE002007FDFFF007FDFFF007FDFFE007FE006007FE006007FE003007FE006007FE004007FE004007FDFFE007FE003007FDFFC007FE001007FE001007FE002007FE006007FE003007FDFFD007FE003007FE005007FDFFE007FDFFE007FE003007FE000007FE004007FE004007FDFFF007FDFFC007FE004007FE005007FDFFF007FDFFF007FE005007FDFFD007FE003007FDFFD007FE004007FE005007FE004007FE000007FE005007FE000007FE003007FE001007FDFFD007FDFFE007FDFFE007FE006007FE005007FE004007FE006007FDFFF007FE001007FDFFF007FDFFF007FE003007FDFFC007FDFFE007FDFFD007FE006007FDFFC007FE002007FE001007FDFFE007FE001007FE002007FDFFF007FDFFD007FE000007FE001007FDFFC007FE004007FE005007FDFFD007FE000007FDFFC007FDFFC007FE005007FDFFD007FDFFC007FE004007FE001007FE003007FDFFF007FDFFF007FDFFE007FE000007FE003007FE005007FE003007FDFFF007FE002007FDFFD007FDFFD007FE004007FE004007FE006007FE005007FDFFD007FE006007FE000007FE006007FDFFE007FDFFF007FE005007FDFFD007FE001007FE004007FE005007FE003007FE004007FE005007FE001007FE000007FE002007FE006007FE003007FDFFE007FE003007FE003007FDFFE007FDFFC007FDFFC007FE005007FDFFD007FE006007FDFFC007FE000007FE005007FE002007FDFFD007FE006007FE002007FDFFD007FDFFE007FE000007FDFFE007FDFFD007FDFFD007FE002007FDFFF007FE002007FE004007FE005007FE002007FDFFE007FE000007FDFFD007FDFFC007FDFFC007FDFFC007FDFFF007FE004007FE006007FDFFE007FDFFC007FE004007FE001007FDFFC007FDFFC007FE000007FE001007FE004007FDFFD007FE001007FE000007FE003007FDFFF007FDFFF007FE004007FDFFC007FDFFE007FDFFF007FE006007FE001007FE004007FE006007FDFFD007FDFFD007FDFFD007FE003007FE004007FDFFF007FE002007FE000007FE006007FE004007FDFFD007FE004007FE005007FE002007FE004007FE002007FE001007FE004007FE004007FE002007FDFFF007FDFFD007FDFFD007FDFFC007FE005007FE003007FE005007FDFFF007FE003007FE004007FDFFE007FDFFF007FE003007FDFFF007FDFFE007FE000007FE004007FE004007FDFFF007FE004007FE006007FE003007FDFFC007FE004007FE000007FE006007FE000007FDFFF007FE006007FE003007FE004007FE003007FE000007FDFFE007FE002007FE005007FDFFE007FE005007FDFFC007FE003007FE005007FDFFC007FE000007FDFFE007FE000007FE001007FE002007FE002007FDFFC007FDFFE007FE006007FDFFC007FDFFF007FE004007FE002007FE005007FDFFC007FE003007FE000007FE000007FDFFE007FE001007FDFFF007FDFFC007FDFFC007FE001007FDFFF007FE003007FE003007FE001007FE001007FE002007FE006007FE005007FDFFE007FE001007FE000007FDFFF007FE004007FDFFC007FDFFE007FDFFE007FDFFF007FDFFC007FDFFF007FE001007FE002007FDFFF007FE004007FE001007FDFFD007FDFFC007FE002007FE002007FE005007FDFFC007FDFFF007FE005007FE000007FE002007FDFFE007FE001007FDFFE007FDFFC007FE006007FDFFF007FE006007FDFFD007FE005007FE004007FDFFE007FDFFE007FE001007FE000007FDFFC007FE002007FDFFC007FE003007FE000007FDFFE007FDFFC007FDFFD007FE000007FE002007FE003007FE000007FE006007FDFFC007FE005007FE004007FE002007FDFFE007FE005007FDFFE007FE005007FE002007FE003007FE005007FDFFE007FDFFF007FDFFC007FDFFF007FE001007FDFFC007FDFFE007FE002007FDFFC007FDFFF007FDFFF007FE003007FE004007FDFFD007FE001007FE000007FDFFD007FDFFD007FE000007FE000007FE001007FE003007FDFFF007FE003007FE002007FE002007FDFFC007FE006007FDFFE007FE005007FE000007FDFFC007FE001007FDFFF007FE002007FDFFE007FE001007FE004007FDFFF007FDFFE007FE006007FE000007FE000007FE004007FDFFE007FE004007FE005007FDFFF007FE001007FE003007FE002007FE004007FDFFE007FE006007FE002007FE003007FE001007FDFFC007FDFFD007FDFFE007FE003007FE000007FDFFC007FE003007FE004007FE003007FDFFC007FE004007FDFFD007FDFFE007FDFFC007FDFFD007FDFFE007FE001007FDFFC007FE000007FE000007FE005007FE000007FE006007FDFFD007FDFFC007FE002007FDFFE007FE001007FE003007FE000007FDFFE007FE000007FE000007FE005007FE003007FE002007FE003007FE006007FE001007FDFFF007FE005007FE005007FDFFE007FE000007FE001007FE006007FE002007FE002007FE006007FE002007FE001007FE004007FDFFF007FE005007FE004007FE003007FE003007FE003007FDFFC007FDFFF007FE001007FDFFC007FE002 +y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w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c = 0000000100000000007FE0000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000001000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000007FE000000000000000000000000000000000000000000000000000007FE000007FE0000000000000000000000000000000000000000000000000000000000000000000007FE0000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000007FE000007FE000000000000000000000000000000000010000000100000001007FE00000000000000000000000000000000000007FE000000000000000000000000000000000010000000000000001000000000000000000000000000000000000000000000000007FE0000000000000000001007FE00000000000007FE0000000000000000000007FE000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001007FE00000000000007FE00000000000007FE0000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000007FE000007FE000000000010000000000000000007FE000007FE0000000000000000000007FE0000000000000000000000000000000000000000001000000000000000000000000000000010000000000000000007FE000007FE00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000007FE000007FE000007FE00000000000007FE0000000000100000000000000000000000000000000007FE00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000007FE0000000000100000001000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000007FE000007FE00000000000000000000000000100000000